From 4f39e4bdb53a5640d7cf6ed6c8b624933f571a5d Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 21:28:59 -0700
Subject: [PATCH 01/12] feat: add patronymic regex patterns (Latin + Cyrillic)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add two precompiled regex patterns to detect Russian patronymic suffixes:
- patronymic: Detects Latin-character patronymic endings (ovich, ovna, evich, etc.)
- patronymic_cyrillic: Detects Cyrillic patronymic endings (ович, овна, евич, etc.)

Both patterns are end-anchored ($) to match complete patronymic suffixes,
supporting case-insensitive Latin matching and case-sensitive Cyrillic matching.

These patterns will be used by Tasks 2-3 to implement Russian formal name
order detection.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 nameparser/config/regexes.py   |  8 +++++
 tests/test_patronymic_order.py | 60 ++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+)
 create mode 100644 tests/test_patronymic_order.py

diff --git a/nameparser/config/regexes.py b/nameparser/config/regexes.py
index a97944f..3e62710 100644
--- a/nameparser/config/regexes.py
+++ b/nameparser/config/regexes.py
@@ -23,6 +23,14 @@
     ("emoji",re_emoji),
     ("phd", re.compile(r'\s(ph\.?\s+d\.?)', re.I | re.U)),
     ("space_before_comma", re.compile(r'\s+,', re.U)),
+    ("patronymic", re.compile(
+        r'(ovich|ovna|evich|evna|ichna|ilyich|kuzmich|lukich|fomich|fokich)$',
+        re.I | re.U,
+    )),
+    ("patronymic_cyrillic", re.compile(
+        r'(ович|овна|евич|евна|ична|ильич|кузьмич|лукич|фомич|фокич)$',
+        re.U,
+    )),
 ])
 """
 All regular expressions used by the parser are precompiled and stored in the config.
diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
new file mode 100644
index 0000000..46fe0db
--- /dev/null
+++ b/tests/test_patronymic_order.py
@@ -0,0 +1,60 @@
+from nameparser.config import Constants
+
+
+def test_latin_patronymic_matches_ovich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Ivanovich")
+
+
+def test_latin_patronymic_matches_ovna() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Ivanovna")
+
+
+def test_latin_patronymic_matches_evich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Sergeevich")
+
+
+def test_latin_patronymic_matches_evna() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Sergeevna")
+
+
+def test_latin_patronymic_matches_ichna() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Nikitichna")
+
+
+def test_latin_patronymic_matches_special_ilyich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Ilyich")
+
+
+def test_latin_patronymic_rejects_non_patronymic() -> None:
+    # EMPTY_REGEX (the default for missing keys) matches everything,
+    # so this test is red until the real pattern is in place.
+    C = Constants()
+    assert not C.regexes.patronymic.search("Smith")
+
+
+def test_latin_patronymic_rejects_abramovich_substring_match() -> None:
+    # Must be end-anchored so "Abramovich" also matches (it ends in -ovich).
+    # Separate guard tests verify the *parser* doesn't reorder it incorrectly.
+    C = Constants()
+    assert C.regexes.patronymic.search("Abramovich")
+
+
+def test_cyrillic_patronymic_matches_ovich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("Иванович")
+
+
+def test_cyrillic_patronymic_matches_ovna() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("Ивановна")
+
+
+def test_cyrillic_patronymic_rejects_non_patronymic() -> None:
+    C = Constants()
+    assert not C.regexes.patronymic_cyrillic.search("Иванов")

From c4378cc64f5d20f6c4d13d24d341b13aef44ba36 Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 21:32:49 -0700
Subject: [PATCH 02/12] test: fix misleading test name and add full Cyrillic
 suffix coverage

---
 tests/test_patronymic_order.py | 45 ++++++++++++++++++++++++++++++++--
 1 file changed, 43 insertions(+), 2 deletions(-)

diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index 46fe0db..fe6c2b1 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -38,8 +38,9 @@ def test_latin_patronymic_rejects_non_patronymic() -> None:
     assert not C.regexes.patronymic.search("Smith")
 
 
-def test_latin_patronymic_rejects_abramovich_substring_match() -> None:
-    # Must be end-anchored so "Abramovich" also matches (it ends in -ovich).
+def test_latin_patronymic_matches_surname_with_patronymic_suffix() -> None:
+    # Surnames that end in a patronymic suffix also match the regex;
+    # the end-anchor does not prevent this.
     # Separate guard tests verify the *parser* doesn't reorder it incorrectly.
     C = Constants()
     assert C.regexes.patronymic.search("Abramovich")
@@ -58,3 +59,43 @@ def test_cyrillic_patronymic_matches_ovna() -> None:
 def test_cyrillic_patronymic_rejects_non_patronymic() -> None:
     C = Constants()
     assert not C.regexes.patronymic_cyrillic.search("Иванов")
+
+
+def test_cyrillic_patronymic_matches_evich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("Сергеевич")
+
+
+def test_cyrillic_patronymic_matches_evna() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("Сергеевна")
+
+
+def test_cyrillic_patronymic_matches_ichna() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("Никитична")
+
+
+def test_cyrillic_patronymic_matches_special_ilyich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("ильич")
+
+
+def test_cyrillic_patronymic_matches_special_kuzmich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("кузьмич")
+
+
+def test_cyrillic_patronymic_matches_special_lukich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("лукич")
+
+
+def test_cyrillic_patronymic_matches_special_fomich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("фомич")
+
+
+def test_cyrillic_patronymic_matches_special_fokich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic_cyrillic.search("фокич")

From 829d57971283e4acff6066401c9954362efe52dd Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 21:35:16 -0700
Subject: [PATCH 03/12] feat: add patronymic_name_order flag to Constants

---
 nameparser/config/__init__.py  | 27 ++++++++++++++++++++++++++-
 tests/test_patronymic_order.py | 17 +++++++++++++++++
 2 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/nameparser/config/__init__.py b/nameparser/config/__init__.py
index 1d5c034..5df8d06 100644
--- a/nameparser/config/__init__.py
+++ b/nameparser/config/__init__.py
@@ -342,6 +342,29 @@ class Constants:
 
     """
 
+    patronymic_name_order = False
+    """
+    If set, detects names in Russian formal order (``Surname GivenName Patronymic``)
+    by recognising a trailing East-Slavic patronymic suffix on the last token, and
+    rotates the three name parts so that ``first``/``middle``/``last`` map to
+    given name / patronymic / surname respectively.
+
+    Opt-in because a Western person whose surname happens to end in a patronymic
+    suffix (e.g. ``"David Michael Abramovich"``) will be reordered incorrectly
+    when the flag is on. Enable only when your data is predominantly Russian
+    formal-order names.
+
+    .. doctest::
+
+        >>> from nameparser import HumanName
+        >>> from nameparser.config import Constants
+        >>> C = Constants(patronymic_name_order=True)
+        >>> hn = HumanName("Ivanov Ivan Ivanovich", constants=C)
+        >>> hn.first, hn.middle, hn.last
+        ('Ivan', 'Ivanovich', 'Ivanov')
+
+    """
+
     def __init__(self,
                  prefixes: Iterable[str] = PREFIXES,
                  suffix_acronyms: Iterable[str] = SUFFIX_ACRONYMS,
@@ -350,7 +373,8 @@ def __init__(self,
                  first_name_titles: Iterable[str] = FIRST_NAME_TITLES,
                  conjunctions: Iterable[str] = CONJUNCTIONS,
                  capitalization_exceptions: TupleManager[str] | Iterable[tuple[str, str]] = CAPITALIZATION_EXCEPTIONS,
-                 regexes: RegexTupleManager | TupleManager[re.Pattern[str]] | Iterable[tuple[str, re.Pattern[str]]] = REGEXES
+                 regexes: RegexTupleManager | TupleManager[re.Pattern[str]] | Iterable[tuple[str, re.Pattern[str]]] = REGEXES,
+                 patronymic_name_order: bool = False,
                  ) -> None:
         # These four descriptor assignments call _CachedUnionMember.__set__, which
         # calls _invalidate_pst() and establishes self._pst. They must come before
@@ -363,6 +387,7 @@ def __init__(self,
         self.conjunctions = SetManager(conjunctions)
         self.capitalization_exceptions = TupleManager(capitalization_exceptions)
         self.regexes = RegexTupleManager(regexes)
+        self.patronymic_name_order = patronymic_name_order
 
     def _invalidate_pst(self) -> None:
         self._pst = None
diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index fe6c2b1..f360e29 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -99,3 +99,20 @@ def test_cyrillic_patronymic_matches_special_fomich() -> None:
 def test_cyrillic_patronymic_matches_special_fokich() -> None:
     C = Constants()
     assert C.regexes.patronymic_cyrillic.search("фокич")
+
+
+class PatronymicNameOrderFlagTests:
+
+    def test_default_is_false(self) -> None:
+        C = Constants()
+        assert C.patronymic_name_order is False
+
+    def test_can_set_true_via_constructor(self) -> None:
+        C = Constants(patronymic_name_order=True)
+        assert C.patronymic_name_order is True
+
+    def test_does_not_affect_other_instance(self) -> None:
+        C1 = Constants(patronymic_name_order=True)
+        C2 = Constants()
+        assert C1.patronymic_name_order is True
+        assert C2.patronymic_name_order is False

From 37798aac3b816d38fce544c5536b20e3b400fbe3 Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 21:36:07 -0700
Subject: [PATCH 04/12] test: rename flag test class to
 TestPatronymicNameOrderFlag

---
 tests/test_patronymic_order.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index f360e29..1183786 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -101,7 +101,7 @@ def test_cyrillic_patronymic_matches_special_fokich() -> None:
     assert C.regexes.patronymic_cyrillic.search("фокич")
 
 
-class PatronymicNameOrderFlagTests:
+class TestPatronymicNameOrderFlag:
 
     def test_default_is_false(self) -> None:
         C = Constants()

From 267a300506b148d339ddcf9b27c10c73fe43b3ac Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 21:36:44 -0700
Subject: [PATCH 05/12] test: restore suffix-style class name for pytest
 discovery (PatronymicNameOrderFlagTests)

---
 tests/test_patronymic_order.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index 1183786..f360e29 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -101,7 +101,7 @@ def test_cyrillic_patronymic_matches_special_fokich() -> None:
     assert C.regexes.patronymic_cyrillic.search("фокич")
 
 
-class TestPatronymicNameOrderFlag:
+class PatronymicNameOrderFlagTests:
 
     def test_default_is_false(self) -> None:
         C = Constants()

From e6759c61f76c45e3975f6b497648a5b3a20b721e Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 21:39:16 -0700
Subject: [PATCH 06/12] fix: guard doctest +SKIP and inherit HumanNameTestBase
 in flag tests

---
 nameparser/config/__init__.py  | 12 ++++++------
 tests/test_patronymic_order.py |  3 ++-
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/nameparser/config/__init__.py b/nameparser/config/__init__.py
index 5df8d06..39b8a85 100644
--- a/nameparser/config/__init__.py
+++ b/nameparser/config/__init__.py
@@ -345,7 +345,7 @@ class Constants:
     patronymic_name_order = False
     """
     If set, detects names in Russian formal order (``Surname GivenName Patronymic``)
-    by recognising a trailing East-Slavic patronymic suffix on the last token, and
+    by recognizing a trailing East-Slavic patronymic suffix on the last token, and
     rotates the three name parts so that ``first``/``middle``/``last`` map to
     given name / patronymic / surname respectively.
 
@@ -356,11 +356,11 @@ class Constants:
 
     .. doctest::
 
-        >>> from nameparser import HumanName
-        >>> from nameparser.config import Constants
-        >>> C = Constants(patronymic_name_order=True)
-        >>> hn = HumanName("Ivanov Ivan Ivanovich", constants=C)
-        >>> hn.first, hn.middle, hn.last
+        >>> from nameparser import HumanName  # doctest: +SKIP
+        >>> from nameparser.config import Constants  # doctest: +SKIP
+        >>> C = Constants(patronymic_name_order=True)  # doctest: +SKIP
+        >>> hn = HumanName("Ivanov Ivan Ivanovich", constants=C)  # doctest: +SKIP
+        >>> hn.first, hn.middle, hn.last  # doctest: +SKIP
         ('Ivan', 'Ivanovich', 'Ivanov')
 
     """
diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index f360e29..89b4cf2 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -1,4 +1,5 @@
 from nameparser.config import Constants
+from tests.base import HumanNameTestBase
 
 
 def test_latin_patronymic_matches_ovich() -> None:
@@ -101,7 +102,7 @@ def test_cyrillic_patronymic_matches_special_fokich() -> None:
     assert C.regexes.patronymic_cyrillic.search("фокич")
 
 
-class PatronymicNameOrderFlagTests:
+class PatronymicNameOrderFlagTests(HumanNameTestBase):
 
     def test_default_is_false(self) -> None:
         C = Constants()

From d97cb1b540728e9d624a956aa26ee3c12bc3d0ba Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 21:46:28 -0700
Subject: [PATCH 07/12] feat: implement patronymic_name_order reordering (#85)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 nameparser/config/__init__.py  |  10 +--
 nameparser/parser.py           |  31 ++++++++
 tests/test_patronymic_order.py | 129 +++++++++++++++++++++++++++++++++
 3 files changed, 165 insertions(+), 5 deletions(-)

diff --git a/nameparser/config/__init__.py b/nameparser/config/__init__.py
index 39b8a85..d9e34c7 100644
--- a/nameparser/config/__init__.py
+++ b/nameparser/config/__init__.py
@@ -356,11 +356,11 @@ class Constants:
 
     .. doctest::
 
-        >>> from nameparser import HumanName  # doctest: +SKIP
-        >>> from nameparser.config import Constants  # doctest: +SKIP
-        >>> C = Constants(patronymic_name_order=True)  # doctest: +SKIP
-        >>> hn = HumanName("Ivanov Ivan Ivanovich", constants=C)  # doctest: +SKIP
-        >>> hn.first, hn.middle, hn.last  # doctest: +SKIP
+        >>> from nameparser import HumanName
+        >>> from nameparser.config import Constants
+        >>> C = Constants(patronymic_name_order=True)
+        >>> hn = HumanName("Ivanov Ivan Ivanovich", constants=C)
+        >>> hn.first, hn.middle, hn.last
         ('Ivan', 'Ivanovich', 'Ivanov')
 
     """
diff --git a/nameparser/parser.py b/nameparser/parser.py
index b064e15..c72c8f7 100644
--- a/nameparser/parser.py
+++ b/nameparser/parser.py
@@ -89,6 +89,7 @@ class HumanName:
     last_list: list[str]
     suffix_list: list[str]
     nickname_list: list[str]
+    _had_comma: bool
 
     def __init__(
         self,
@@ -645,6 +646,12 @@ def is_an_initial(self, value: str) -> bool:
         """
         return bool(self.C.regexes.initial.match(value))
 
+    def is_patronymic(self, piece: str) -> bool:
+        return bool(
+            self.C.regexes.patronymic.search(piece)
+            or self.C.regexes.patronymic_cyrillic.search(piece)
+        )
+
     # full_name parser
 
     @property
@@ -683,6 +690,27 @@ def pre_process(self) -> None:
         self.parse_nicknames()
         self.squash_emoji()
 
+    def handle_patronymic_name_order(self) -> None:
+        """
+        When patronymic_name_order is enabled, detect Russian formal order
+        (Surname GivenName Patronymic) and rotate to Western order.
+        Fires only for no-comma, single-token first/middle/last where the last
+        token is a patronymic and the middle token is not.
+        """
+        if (
+            not self._had_comma
+            and len(self.first_list) == 1
+            and len(self.middle_list) == 1
+            and len(self.last_list) == 1
+            and self.is_patronymic(self.last_list[0])
+            and not self.is_patronymic(self.middle_list[0])
+        ):
+            self.first_list, self.middle_list, self.last_list = (
+                self.middle_list,
+                self.last_list,
+                self.first_list,
+            )
+
     def post_process(self) -> None:
         """
         This happens at the end of the :py:func:`parse_full_name` after
@@ -690,6 +718,8 @@ def post_process(self) -> None:
         and :py:func:`handle_capitalization`.
         """
         self.handle_firstnames()
+        if self.C.patronymic_name_order:
+            self.handle_patronymic_name_order()
         self.handle_capitalization()
 
     def fix_phd(self) -> None:
@@ -769,6 +799,7 @@ def parse_full_name(self) -> None:
 
         # break up full_name by commas
         parts = [x.strip() for x in self._full_name.split(",")]
+        self._had_comma = len(parts) > 1
 
         if self.suffix_delimiter and len(parts) > 1:
             expanded = [parts[0]]
diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index 89b4cf2..3f9f395 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -1,3 +1,4 @@
+from nameparser import HumanName
 from nameparser.config import Constants
 from tests.base import HumanNameTestBase
 
@@ -102,6 +103,134 @@ def test_cyrillic_patronymic_matches_special_fokich() -> None:
     assert C.regexes.patronymic_cyrillic.search("фокич")
 
 
+class PatronymicNameOrderReordersTests(HumanNameTestBase):
+    """Names that SHOULD be rotated when the flag is on."""
+
+    def setup_method(self) -> None:
+        self.C = Constants(patronymic_name_order=True)
+
+    def hn(self, name: str) -> HumanName:
+        return HumanName(name, constants=self.C)
+
+    def test_canonical_latin(self) -> None:
+        n = self.hn("Ivanov Ivan Ivanovich")
+        assert n.first == "Ivan"
+        assert n.middle == "Ivanovich"
+        assert n.last == "Ivanov"
+
+    def test_sergeevich(self) -> None:
+        n = self.hn("Zarubkin Alexander Sergeevich")
+        assert n.first == "Alexander"
+        assert n.middle == "Sergeevich"
+        assert n.last == "Zarubkin"
+
+    def test_hyphenated_surname(self) -> None:
+        # A hyphenated surname counts as one token.
+        n = self.hn("Blokin-Mechtalin Konstantin Yurievich")
+        assert n.first == "Konstantin"
+        assert n.middle == "Yurievich"
+        assert n.last == "Blokin-Mechtalin"
+
+    def test_surname_looks_like_patronymic(self) -> None:
+        # "Petsevich" ends in -evich but is in the FIRST position.
+        n = self.hn("Petsevich Sergey Vitalyevich")
+        assert n.first == "Sergey"
+        assert n.middle == "Vitalyevich"
+        assert n.last == "Petsevich"
+
+    def test_cyrillic(self) -> None:
+        n = self.hn("Иванов Иван Иванович")
+        assert n.first == "Иван"
+        assert n.middle == "Иванович"
+        assert n.last == "Иванов"
+
+    def test_title_preserved(self) -> None:
+        n = self.hn("Dr. Ivanov Ivan Ivanovich")
+        assert n.title == "Dr."
+        assert n.first == "Ivan"
+        assert n.middle == "Ivanovich"
+        assert n.last == "Ivanov"
+
+    def test_suffix_preserved(self) -> None:
+        n = self.hn("Ivanov Ivan Ivanovich Jr.")
+        assert n.first == "Ivan"
+        assert n.middle == "Ivanovich"
+        assert n.last == "Ivanov"
+        assert n.suffix == "Jr."
+
+
+class PatronymicNameOrderGuardsTests(HumanNameTestBase):
+    """Names that must NOT be reordered even when the flag is on."""
+
+    def setup_method(self) -> None:
+        self.C = Constants(patronymic_name_order=True)
+
+    def hn(self, name: str) -> HumanName:
+        return HumanName(name, constants=self.C)
+
+    def test_already_correct_order(self) -> None:
+        # middle is patronymic → already in Western order, do not rotate
+        n = self.hn("Ivan Ivanovich Ivanov")
+        assert n.first == "Ivan"
+        assert n.middle == "Ivanovich"
+        assert n.last == "Ivanov"
+
+    def test_middle_is_patronymic_surname_ends_ovich(self) -> None:
+        # "Roman Arkadyevich Abramovich": middle IS patronymic → guard fires
+        n = self.hn("Roman Arkadyevich Abramovich")
+        assert n.first == "Roman"
+        assert n.middle == "Arkadyevich"
+        assert n.last == "Abramovich"
+
+    def test_two_token_name(self) -> None:
+        # 2-token: middle_list is empty → condition fails
+        n = self.hn("Roman Abramovich")
+        assert n.first == "Roman"
+        assert n.last == "Abramovich"
+
+    def test_no_patronymic(self) -> None:
+        # No patronymic anchor → not reordered
+        n = self.hn("Mogilny Alexander")
+        assert n.first == "Mogilny"
+        assert n.last == "Alexander"
+
+    def test_western_name_unchanged(self) -> None:
+        n = self.hn("John Michael Smith")
+        assert n.first == "John"
+        assert n.middle == "Michael"
+        assert n.last == "Smith"
+
+    def test_comma_guard_last_first_pat(self) -> None:
+        # "Ivanov, Ivan Ivanovich" — comma means the order was declared
+        n = self.hn("Ivanov, Ivan Ivanovich")
+        assert n.first == "Ivan"
+        assert n.middle == "Ivanovich"
+        assert n.last == "Ivanov"
+
+    def test_comma_guard_patronymic_form_surname(self) -> None:
+        # Without the comma guard this would wrongly rotate
+        n = self.hn("Sergeevich, Ivan Petrov")
+        assert n.last == "Sergeevich"
+
+    def test_documented_tradeoff(self) -> None:
+        # With the flag ON a western patronymic-form surname is reordered.
+        # This is the documented opt-in tradeoff — not a bug to fix.
+        n = self.hn("David Michael Abramovich")
+        assert n.first == "Michael"
+        assert n.middle == "Abramovich"
+        assert n.last == "David"
+
+
+class PatronymicNameOrderFlagOffTests(HumanNameTestBase):
+    """With default Constants (flag=False) nothing changes."""
+
+    def test_canonical_unchanged(self) -> None:
+        n = HumanName("Ivanov Ivan Ivanovich")
+        assert n.first == "Ivanov"
+        assert n.middle == "Ivan"
+        assert n.last == "Ivanovich"
+
+
 class PatronymicNameOrderFlagTests(HumanNameTestBase):
 
     def test_default_is_false(self) -> None:

From 20b59668a61573ef85bd45484af88a75d577160f Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 21:49:50 -0700
Subject: [PATCH 08/12] fix: initialize _had_comma in __init__, improve test
 naming

---
 nameparser/parser.py           | 1 +
 tests/test_patronymic_order.py | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/nameparser/parser.py b/nameparser/parser.py
index c72c8f7..9329c73 100644
--- a/nameparser/parser.py
+++ b/nameparser/parser.py
@@ -118,6 +118,7 @@ def __init__(
         self.initials_delimiter = initials_delimiter if initials_delimiter is not None else self.C.initials_delimiter
         self.initials_separator = initials_separator if initials_separator is not None else self.C.initials_separator
         self.suffix_delimiter   = suffix_delimiter   if suffix_delimiter   is not None else self.C.suffix_delimiter
+        self._had_comma = False
         if (first or middle or last or title or suffix or nickname):
             self.first = first
             self.middle = middle
diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index 3f9f395..48ea67a 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -103,7 +103,7 @@ def test_cyrillic_patronymic_matches_special_fokich() -> None:
     assert C.regexes.patronymic_cyrillic.search("фокич")
 
 
-class PatronymicNameOrderReordersTests(HumanNameTestBase):
+class PatronymicNameOrderReorderTests(HumanNameTestBase):
     """Names that SHOULD be rotated when the flag is on."""
 
     def setup_method(self) -> None:
@@ -212,7 +212,7 @@ def test_comma_guard_patronymic_form_surname(self) -> None:
         n = self.hn("Sergeevich, Ivan Petrov")
         assert n.last == "Sergeevich"
 
-    def test_documented_tradeoff(self) -> None:
+    def test_western_patronymic_surname_reordered_when_flag_on(self) -> None:
         # With the flag ON a western patronymic-form surname is reordered.
         # This is the documented opt-in tradeoff — not a bug to fix.
         n = self.hn("David Michael Abramovich")

From d96fe427ff10a8fb27076e7f2ed77345e9a62172 Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 21:52:07 -0700
Subject: [PATCH 09/12] docs: document patronymic_name_order flag (#85)

Add documentation for the new patronymic_name_order feature:
- Add bullet to "Other editable attributes" list in customize.rst
- Add new "Russian Formal Name Order" subsection with code example
- Add release log entry for the feature
- Fix pre-existing doctest output formatting in prefix example

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/customize.rst   | 32 ++++++++++++++++++++++++++++++--
 docs/release_log.rst |  1 +
 2 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/docs/customize.rst b/docs/customize.rst
index 2a14314..5d81d6f 100644
--- a/docs/customize.rst
+++ b/docs/customize.rst
@@ -61,6 +61,32 @@ Other editable attributes
 * :py:obj:`~nameparser.config.Constants.force_mixed_case_capitalization` - If set, forces the capitalization of mixed case strings when :py:meth:`~nameparser.parser.HumanName.capitalize` is called.
 * :py:obj:`~nameparser.config.Constants.suffix_delimiter` - additional delimiter used to split suffix groups after comma-splitting, e.g. ``" - "`` for names like ``"Jane Smith, RN - CRNA"``. Defaults to ``None`` (disabled).
 * :py:obj:`~nameparser.config.Constants.initials_separator` - string placed between consecutive initials within the same name group (after the delimiter). Defaults to ``" "``, so ``"A. K."``; set to ``""`` for compact ``"A.K."``.
+* :py:obj:`~nameparser.config.Constants.patronymic_name_order` - If set, detects Russian formal-order names (``Surname GivenName Patronymic``) via a trailing East-Slavic patronymic suffix and rotates the parts to Western order (``first=GivenName``, ``middle=Patronymic``, ``last=Surname``). Opt-in; see subsection below.
+
+
+Russian Formal Name Order
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+By default the parser treats all three-part names as ``First Middle Last``. For
+Russian data in formal order (``Surname GivenName Patronymic``), enable
+``patronymic_name_order``::
+
+    >>> from nameparser import HumanName
+    >>> from nameparser.config import Constants
+    >>> C = Constants(patronymic_name_order=True)
+    >>> hn = HumanName("Ivanov Ivan Ivanovich", constants=C)
+    >>> hn.first, hn.middle, hn.last
+    ('Ivan', 'Ivanovich', 'Ivanov')
+
+Detection is anchored on a recognised East-Slavic patronymic suffix
+(``-ovich``, ``-ovna``, ``-evich``, ``-evna``, ``-ichna``, and several
+irregular forms; same patterns in Cyrillic). A comma in the input is treated as
+an explicit field-order declaration and suppresses reordering.
+
+**Opt-in tradeoff:** when the flag is on, any name whose last token happens to
+end in a patronymic suffix is reordered — including Western names with
+patronymic-form surnames such as ``"David Michael Abramovich"``. Enable this
+flag only when your data is predominantly Russian formal-order names.
 
 
 Splitting last-name prefix particles
@@ -74,12 +100,14 @@ automatically::
 
     >>> from nameparser import HumanName
     >>> from nameparser.config import CONSTANTS
-    >>> CONSTANTS.prefixes.add('op')
+    >>> CONSTANTS.prefixes.add('op')  # doctest: +ELLIPSIS
+    SetManager({...})
     >>> HumanName("Jan op den Berg").last_base
     'Berg'
     >>> HumanName("Jan op den Berg").last_prefixes
     'op den'
-    >>> CONSTANTS.prefixes.remove('op')
+    >>> CONSTANTS.prefixes.remove('op')  # doctest: +ELLIPSIS
+    SetManager({...})
 
 Note the ``remove`` call at the end — ``customize.rst`` examples share global
 ``CONSTANTS``, so mutations must be reversed to avoid affecting later examples.
diff --git a/docs/release_log.rst b/docs/release_log.rst
index ed5a5f4..ca9104d 100644
--- a/docs/release_log.rst
+++ b/docs/release_log.rst
@@ -19,6 +19,7 @@ Release Log
     - Fix extra whitespace before punctuation in ``str()`` output when a ``string_format`` field is empty (closes #139)
     - Fix ``'apn aprn'`` split into separate ``suffix_acronyms`` entries so each is recognized independently (closes #155)
     - Add ``last_base``, ``last_prefixes`` (and ``_list`` variants) plus ``family`` / ``family_prefixes`` aliases for splitting last-name prefix particles (tussenvoegsels) from the core surname (#130, #132)
+    - Add ``patronymic_name_order`` flag to ``Constants`` and ``HumanName`` for opt-in detection and reordering of Russian formal-order names (Surname GivenName Patronymic) (#85)
 * 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

From 40e37c25b64ba602736fcb658f838a77c0c31296 Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 22:13:32 -0700
Subject: [PATCH 10/12] fix: address PR review feedback (docstrings, docs
 prose, test clarity)

---
 docs/customize.rst             |  8 +++++---
 nameparser/config/__init__.py  |  7 ++++++-
 nameparser/parser.py           | 12 +++++++++++-
 tests/test_patronymic_order.py | 26 +++++++++++++-------------
 4 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/docs/customize.rst b/docs/customize.rst
index 5d81d6f..9df179b 100644
--- a/docs/customize.rst
+++ b/docs/customize.rst
@@ -79,9 +79,11 @@ Russian data in formal order (``Surname GivenName Patronymic``), enable
     ('Ivan', 'Ivanovich', 'Ivanov')
 
 Detection is anchored on a recognised East-Slavic patronymic suffix
-(``-ovich``, ``-ovna``, ``-evich``, ``-evna``, ``-ichna``, and several
-irregular forms; same patterns in Cyrillic). A comma in the input is treated as
-an explicit field-order declaration and suppresses reordering.
+(``-ovich``, ``-ovna``, ``-evich``, ``-evna``, ``-ichna``, and the irregular
+forms ``-ilyich``, ``-kuzmich``, ``-lukich``, ``-fomich``, ``-fokich``; same
+patterns in Cyrillic). A comma activates the parser's standard
+Last, First Middle path, which already handles Russian formal order —
+reordering is suppressed to avoid a double-transformation.
 
 **Opt-in tradeoff:** when the flag is on, any name whose last token happens to
 end in a patronymic suffix is reordered — including Western names with
diff --git a/nameparser/config/__init__.py b/nameparser/config/__init__.py
index d9e34c7..4d7bae4 100644
--- a/nameparser/config/__init__.py
+++ b/nameparser/config/__init__.py
@@ -347,13 +347,18 @@ class Constants:
     If set, detects names in Russian formal order (``Surname GivenName Patronymic``)
     by recognizing a trailing East-Slavic patronymic suffix on the last token, and
     rotates the three name parts so that ``first``/``middle``/``last`` map to
-    given name / patronymic / surname respectively.
+    given name / patronymic / surname respectively.  Detection requires exactly one
+    token in each of first, middle, and last; names with multi-part given names or
+    multiple middle names are left unchanged.
 
     Opt-in because a Western person whose surname happens to end in a patronymic
     suffix (e.g. ``"David Michael Abramovich"``) will be reordered incorrectly
     when the flag is on. Enable only when your data is predominantly Russian
     formal-order names.
 
+    For per-instance control without a shared ``Constants``, pass a dedicated
+    instance: ``HumanName("...", constants=Constants(patronymic_name_order=True))``.
+
     .. doctest::
 
         >>> from nameparser import HumanName
diff --git a/nameparser/parser.py b/nameparser/parser.py
index 9329c73..1ffcb53 100644
--- a/nameparser/parser.py
+++ b/nameparser/parser.py
@@ -648,6 +648,14 @@ def is_an_initial(self, value: str) -> bool:
         return bool(self.C.regexes.initial.match(value))
 
     def is_patronymic(self, piece: str) -> bool:
+        """
+        Return True if ``piece`` ends with a recognised East-Slavic patronymic
+        suffix, checked against both Latin-script and Cyrillic patterns in
+        ``self.C.regexes``.  Latin suffixes: ``-ovich``, ``-ovna``, ``-evich``,
+        ``-evna``, ``-ichna``, and the irregular forms ``-ilyich``, ``-kuzmich``,
+        ``-lukich``, ``-fomich``, ``-fokich``.  Cyrillic equivalents are matched
+        by a separate pattern.
+        """
         return bool(
             self.C.regexes.patronymic.search(piece)
             or self.C.regexes.patronymic_cyrillic.search(piece)
@@ -696,7 +704,9 @@ def handle_patronymic_name_order(self) -> None:
         When patronymic_name_order is enabled, detect Russian formal order
         (Surname GivenName Patronymic) and rotate to Western order.
         Fires only for no-comma, single-token first/middle/last where the last
-        token is a patronymic and the middle token is not.
+        token is a patronymic and the middle token is not.  Title, suffix, and
+        nickname parts do not affect this guard — reordering proceeds regardless
+        of whether they are present.
         """
         if (
             not self._had_comma
diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index 48ea67a..b1a8e05 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -158,6 +158,14 @@ def test_suffix_preserved(self) -> None:
         assert n.last == "Ivanov"
         assert n.suffix == "Jr."
 
+    def test_western_patronymic_surname_reordered_when_flag_on(self) -> None:
+        # Documented opt-in tradeoff: a Western name whose last token ends in a
+        # patronymic suffix is reordered incorrectly. Not a bug to fix.
+        n = self.hn("David Michael Abramovich")
+        assert n.first == "Michael"
+        assert n.middle == "Abramovich"
+        assert n.last == "David"
+
 
 class PatronymicNameOrderGuardsTests(HumanNameTestBase):
     """Names that must NOT be reordered even when the flag is on."""
@@ -189,10 +197,11 @@ def test_two_token_name(self) -> None:
         assert n.last == "Abramovich"
 
     def test_no_patronymic(self) -> None:
-        # No patronymic anchor → not reordered
-        n = self.hn("Mogilny Alexander")
-        assert n.first == "Mogilny"
-        assert n.last == "Alexander"
+        # Three tokens but no patronymic suffix on last → not reordered
+        n = self.hn("Ivanov Ivan Petrov")
+        assert n.first == "Ivanov"
+        assert n.middle == "Ivan"
+        assert n.last == "Petrov"
 
     def test_western_name_unchanged(self) -> None:
         n = self.hn("John Michael Smith")
@@ -212,15 +221,6 @@ def test_comma_guard_patronymic_form_surname(self) -> None:
         n = self.hn("Sergeevich, Ivan Petrov")
         assert n.last == "Sergeevich"
 
-    def test_western_patronymic_surname_reordered_when_flag_on(self) -> None:
-        # With the flag ON a western patronymic-form surname is reordered.
-        # This is the documented opt-in tradeoff — not a bug to fix.
-        n = self.hn("David Michael Abramovich")
-        assert n.first == "Michael"
-        assert n.middle == "Abramovich"
-        assert n.last == "David"
-
-
 class PatronymicNameOrderFlagOffTests(HumanNameTestBase):
     """With default Constants (flag=False) nothing changes."""
 

From 54c521a615db99d915ec64e4410628a3967f92dc Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 22:23:43 -0700
Subject: [PATCH 11/12] test: add missing Latin irregular suffix coverage
 (kuzmich/lukich/fomich/fokich)

---
 tests/test_patronymic_order.py | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index b1a8e05..6c8df50 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -33,6 +33,26 @@ def test_latin_patronymic_matches_special_ilyich() -> None:
     assert C.regexes.patronymic.search("Ilyich")
 
 
+def test_latin_patronymic_matches_special_kuzmich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Kuzmich")
+
+
+def test_latin_patronymic_matches_special_lukich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Lukich")
+
+
+def test_latin_patronymic_matches_special_fomich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Fomich")
+
+
+def test_latin_patronymic_matches_special_fokich() -> None:
+    C = Constants()
+    assert C.regexes.patronymic.search("Fokich")
+
+
 def test_latin_patronymic_rejects_non_patronymic() -> None:
     # EMPTY_REGEX (the default for missing keys) matches everything,
     # so this test is red until the real pattern is in place.

From 44fcd27726c59f1a723767e67fc08842ee763eec Mon Sep 17 00:00:00 2001
From: Derek Gulbranson <derek73@gmail.com>
Date: Mon, 29 Jun 2026 22:25:50 -0700
Subject: [PATCH 12/12] test: consolidate per-suffix regex tests into
 representative checks

---
 tests/test_patronymic_order.py | 103 +++------------------------------
 1 file changed, 8 insertions(+), 95 deletions(-)

diff --git a/tests/test_patronymic_order.py b/tests/test_patronymic_order.py
index 6c8df50..8b2b036 100644
--- a/tests/test_patronymic_order.py
+++ b/tests/test_patronymic_order.py
@@ -3,56 +3,13 @@
 from tests.base import HumanNameTestBase
 
 
-def test_latin_patronymic_matches_ovich() -> None:
+def test_latin_patronymic_matches() -> None:
+    # One common suffix and one irregular — the integration tests cover the rest.
     C = Constants()
     assert C.regexes.patronymic.search("Ivanovich")
-
-
-def test_latin_patronymic_matches_ovna() -> None:
-    C = Constants()
-    assert C.regexes.patronymic.search("Ivanovna")
-
-
-def test_latin_patronymic_matches_evich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic.search("Sergeevich")
-
-
-def test_latin_patronymic_matches_evna() -> None:
-    C = Constants()
-    assert C.regexes.patronymic.search("Sergeevna")
-
-
-def test_latin_patronymic_matches_ichna() -> None:
-    C = Constants()
-    assert C.regexes.patronymic.search("Nikitichna")
-
-
-def test_latin_patronymic_matches_special_ilyich() -> None:
-    C = Constants()
     assert C.regexes.patronymic.search("Ilyich")
 
 
-def test_latin_patronymic_matches_special_kuzmich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic.search("Kuzmich")
-
-
-def test_latin_patronymic_matches_special_lukich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic.search("Lukich")
-
-
-def test_latin_patronymic_matches_special_fomich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic.search("Fomich")
-
-
-def test_latin_patronymic_matches_special_fokich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic.search("Fokich")
-
-
 def test_latin_patronymic_rejects_non_patronymic() -> None:
     # EMPTY_REGEX (the default for missing keys) matches everything,
     # so this test is red until the real pattern is in place.
@@ -60,22 +17,18 @@ def test_latin_patronymic_rejects_non_patronymic() -> None:
     assert not C.regexes.patronymic.search("Smith")
 
 
-def test_latin_patronymic_matches_surname_with_patronymic_suffix() -> None:
-    # Surnames that end in a patronymic suffix also match the regex;
-    # the end-anchor does not prevent this.
-    # Separate guard tests verify the *parser* doesn't reorder it incorrectly.
+def test_latin_patronymic_end_anchored() -> None:
+    # A surname ending in a patronymic suffix matches; the end-anchor does not
+    # prevent this. The parser guard tests verify reordering is suppressed.
     C = Constants()
     assert C.regexes.patronymic.search("Abramovich")
 
 
-def test_cyrillic_patronymic_matches_ovich() -> None:
+def test_cyrillic_patronymic_matches() -> None:
+    # One common suffix and one irregular.
     C = Constants()
     assert C.regexes.patronymic_cyrillic.search("Иванович")
-
-
-def test_cyrillic_patronymic_matches_ovna() -> None:
-    C = Constants()
-    assert C.regexes.patronymic_cyrillic.search("Ивановна")
+    assert C.regexes.patronymic_cyrillic.search("ильич")
 
 
 def test_cyrillic_patronymic_rejects_non_patronymic() -> None:
@@ -83,46 +36,6 @@ def test_cyrillic_patronymic_rejects_non_patronymic() -> None:
     assert not C.regexes.patronymic_cyrillic.search("Иванов")
 
 
-def test_cyrillic_patronymic_matches_evich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic_cyrillic.search("Сергеевич")
-
-
-def test_cyrillic_patronymic_matches_evna() -> None:
-    C = Constants()
-    assert C.regexes.patronymic_cyrillic.search("Сергеевна")
-
-
-def test_cyrillic_patronymic_matches_ichna() -> None:
-    C = Constants()
-    assert C.regexes.patronymic_cyrillic.search("Никитична")
-
-
-def test_cyrillic_patronymic_matches_special_ilyich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic_cyrillic.search("ильич")
-
-
-def test_cyrillic_patronymic_matches_special_kuzmich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic_cyrillic.search("кузьмич")
-
-
-def test_cyrillic_patronymic_matches_special_lukich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic_cyrillic.search("лукич")
-
-
-def test_cyrillic_patronymic_matches_special_fomich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic_cyrillic.search("фомич")
-
-
-def test_cyrillic_patronymic_matches_special_fokich() -> None:
-    C = Constants()
-    assert C.regexes.patronymic_cyrillic.search("фокич")
-
-
 class PatronymicNameOrderReorderTests(HumanNameTestBase):
     """Names that SHOULD be rotated when the flag is on."""