nameparser 1.3.1__tar.gz → 1.4.0__tar.gz

{nameparser-1.3.1/nameparser.egg-info → nameparser-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 1.3.1
+Version: 1.4.0
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
 License: LGPL
@@ -31,8 +31,14 @@ Name Parser
 
 |Build Status| |PyPI| |PyPI version| |Documentation| |License| |Downloads| |Codecov|
 
+📣 **nameparser 2.0 is in design** — a new immutable core API, with full
+compatibility for existing code through 2.x. Read the `design RFC
+<https://github.com/derek73/python-nameparser/pull/285>`__ and share
+feedback on `the discussion issue
+<https://github.com/derek73/python-nameparser/issues/284>`__.
+
 A simple Python (3.10+) module for parsing human names into their
-individual components. 
+individual components.
 
 * hn.title
 * hn.first

{nameparser-1.3.1 → nameparser-1.4.0}/README.rst

@@ -3,8 +3,14 @@ Name Parser
 
 |Build Status| |PyPI| |PyPI version| |Documentation| |License| |Downloads| |Codecov|
 
+📣 **nameparser 2.0 is in design** — a new immutable core API, with full
+compatibility for existing code through 2.x. Read the `design RFC
+<https://github.com/derek73/python-nameparser/pull/285>`__ and share
+feedback on `the discussion issue
+<https://github.com/derek73/python-nameparser/issues/284>`__.
+
 A simple Python (3.10+) module for parsing human names into their
-individual components. 
+individual components.
 
 * hn.title
 * hn.first

{nameparser-1.3.1 → nameparser-1.4.0}/nameparser/_version.py

@@ -1,2 +1,2 @@
-VERSION = (1, 3, 1)
+VERSION = (1, 4, 0)
 __version__ = '.'.join(map(str, VERSION))

{nameparser-1.3.1 → nameparser-1.4.0}/nameparser/config/__init__.py

@@ -1,31 +1,46 @@
 """
 The :py:mod:`nameparser.config` module manages the configuration of the
-nameparser. 
+nameparser.
 
-A module-level instance of :py:class:`~nameparser.config.Constants` is created
-and used by default for all HumanName instances. You can adjust the entire module's
-configuration by importing this instance and changing it.
+:py:class:`~nameparser.config.Constants` is for application-level
+configuration, set once at startup. ``CONSTANTS``, the module-level instance
+used by every ``HumanName`` created without its own config, is the only
+channel that reaches parses happening in code you don't own (helpers,
+pipelines, a third-party library using nameparser internally) -- the same
+role ``logging`` and ``locale`` play elsewhere. Import it and change it
+directly:
 
 ::
 
     >>> from nameparser.config import CONSTANTS
     >>> CONSTANTS.titles.remove('hon').add('chemistry','dean') # doctest: +SKIP
 
-You can also adjust the configuration of individual instances by passing
-``None`` as the second argument upon instantiation.
+For anything scoped -- one dataset, one library, one test -- pass your own
+:py:class:`Constants` instance as the second argument upon instantiation
+instead: ``Constants()`` for fresh library defaults, or ``CONSTANTS.copy()``
+for a private snapshot of the current module config.
 
 ::
 
     >>> from nameparser import HumanName
-    >>> hn = HumanName("Dean Robert Johns", None)
+    >>> from nameparser.config import Constants
+    >>> hn = HumanName("Dean Robert Johns", Constants())
     >>> hn.C.titles.add('dean') # doctest: +SKIP
     >>> hn.parse_full_name() # need to run this again after config changes
 
-**Potential Gotcha**: If you do not pass ``None`` (or your own
-:py:class:`Constants` instance) as the second argument, ``hn.C`` will be a
-reference to the module config, possibly yielding unexpected results. See
-`Customizing the Parser <customize.html>`_.
+Mixing the two up is where the surprises come from, not the API itself: if
+you do not pass your own :py:class:`Constants` instance as the second
+argument, ``hn.C`` will be a reference to the module config, and a change
+there reaches every other instance sharing it. See `Customizing the Parser
+<customize.html>`_.
+
+.. deprecated:: 1.4.0
+    Passing ``None`` as the second argument also builds a fresh
+    ``Constants()``, but is deprecated in favor of the explicit spellings
+    above; it will raise ``TypeError`` in 2.0 (issue #260).
 """
+import copy
+import inspect
 import re
 import sys
 import warnings
@@ -242,7 +257,18 @@ class SetManager(Set):
         .. deprecated:: 1.3.0
             ``bytes`` arguments will raise ``TypeError`` in 2.0 (see issue
             #245); decode before adding.
+
+        .. deprecated:: 1.4.0
+            The method itself is removed in 2.0 (see issue #245); use
+            :py:func:`add` instead, decoding bytes first.
         """
+        warnings.warn(
+            "SetManager.add_with_encoding() is deprecated and will be "
+            "removed in 2.0; use add() instead (decode bytes first). See "
+            "https://github.com/derek73/python-nameparser/issues/245",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         self._add_normalized(s, encoding, stacklevel=3)
 
     def add(self, *strings: str) -> Self:
@@ -327,7 +353,7 @@ def _is_dunder(attr: str) -> bool:
 # validate and normalize each one exactly once at import. Constants()
 # copies these via _normalized_elements' SetManager fast path instead of
 # re-checking ~1,400 elements per construction — a cost that otherwise
-# repeats on the per-instance-config path, HumanName(constants=None).
+# repeats on the per-instance-config path, HumanName(constants=Constants()).
 #
 # This snapshot is taken once, at import time: mutating a raw constant
 # (e.g. `TITLES.add('x')`) after import is *not* picked up by Constants()
@@ -383,10 +409,28 @@ class TupleManager(dict[str, T]):
             arg = checked
         super().__init__(arg, **kwargs)
 
+    def _warn_unknown_key(self, attr: str) -> None:
+        # Deprecated 1.4.0, raises AttributeError in 2.0 (#256): a misspelled
+        # key otherwise degrades silently with no traceback pointing at the
+        # typo.
+        warnings.warn(
+            f"{attr!r} is not a known key ({', '.join(sorted(self))}); "
+            "unknown-key attribute access is deprecated and will raise "
+            "AttributeError in 2.0. Use .get() for intentional soft access. "
+            "See https://github.com/derek73/python-nameparser/issues/256",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+
     def __getattr__(self, attr: str) -> T | None:
         # Otherwise the dict default (None) is mistaken for a real protocol hook.
         if _is_dunder(attr):
             raise AttributeError(attr)
+        # Single-underscore introspection probes (IPython/Jupyter's
+        # _repr_html_, _ipython_canary_method_should_not_exist_, etc.) are
+        # never config keys either -- no real config key starts with '_'.
+        if attr not in self and not attr.startswith('_'):
+            self._warn_unknown_key(attr)
         return self.get(attr)
 
     def __setattr__(self, attr: str, value: T) -> None:
@@ -430,6 +474,8 @@ class RegexTupleManager(TupleManager[re.Pattern[str]]):
         # then tries to call the returned re.Pattern and raises TypeError.
         if _is_dunder(attr):
             raise AttributeError(attr)
+        if attr not in self and not attr.startswith('_'):
+            self._warn_unknown_key(attr)
         return self.get(attr, EMPTY_REGEX)
 
 
@@ -495,6 +541,48 @@ class _CachedUnionMember(_SetManagerAttribute):
         setattr(obj, self._attr, value)
 
 
+class _EmptyAttributeDefaultAttribute:
+    """Descriptor backing ``Constants.empty_attribute_default``.
+
+    .. deprecated:: 1.4.0
+        Assignment is deprecated (see issue #255): the only legal value
+        left once ``None`` support goes in 2.0 is the default ``''``, so a
+        dial with one position isn't configuration.
+    """
+
+    _attr = '_empty_attribute_default'
+
+    def __get__(self, obj: 'Constants | None', objtype: type | None = None) -> str:
+        # Annotated `str`, not `str | None`, to match the pre-descriptor
+        # plain-attribute inference: None is documented/supported (see the
+        # class docstring), but typing it honestly cascades `| None`
+        # through every public str-typed name accessor (title, first, ...).
+        # Returning '' rather than `self` on class access (unlike
+        # _SetManagerAttribute, which returns `self`) is also load-bearing
+        # for Constants.__repr__'s `getattr(type(self), name)` default
+        # comparison in _repr_scalar_attrs -- returning `self` there would
+        # make every Constants() show this attribute as "customized".
+        if obj is None:
+            return ''
+        return getattr(obj, self._attr, '')
+
+    def __set__(self, obj: 'Constants', value: str | None) -> None:
+        if value is not None and not isinstance(value, str):
+            raise TypeError(
+                f"empty_attribute_default must be a str or None, got "
+                f"{type(value).__name__!r}"
+            )
+        warnings.warn(
+            "Assigning Constants.empty_attribute_default is deprecated and "
+            "will raise TypeError in 2.0; empty attributes will always "
+            "return ''. See "
+            "https://github.com/derek73/python-nameparser/issues/255",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        setattr(obj, self._attr, value)
+
+
 class Constants:
     """
     An instance of this class hold all of the configuration constants for the parser.
@@ -590,8 +678,9 @@ class Constants:
     ``None`` (no additional splitting beyond the standard comma split).
 
     Note: setting this to ``","`` or ``", "`` has no additional effect —
-    the full name is already split on bare commas first, and each resulting
-    part is stripped of surrounding whitespace before this step runs.
+    the full name is already split on comma characters first (including the
+    Arabic ``،`` and fullwidth ``，`` variants), and each resulting part is
+    stripped of surrounding whitespace before this step runs.
 
     The delimiter is only applied to parts once they've been identified as
     a suffix group, so it never leaks into a first- or middle-name part. For
@@ -600,20 +689,29 @@ class Constants:
     does not get mistaken for a suffix split.
     """
 
-    empty_attribute_default = ''
+    empty_attribute_default = _EmptyAttributeDefaultAttribute()
     """
     Default return value for empty attributes.
 
+    .. deprecated:: 1.4.0
+        Assignment emits ``DeprecationWarning``; the option is removed in
+        2.0 (see issue #255) and empty attributes will always return ``''``.
+
     .. doctest::
 
+        >>> import warnings
         >>> from nameparser.config import CONSTANTS
-        >>> CONSTANTS.empty_attribute_default = None
+        >>> with warnings.catch_warnings():
+        ...     warnings.simplefilter('ignore', DeprecationWarning)
+        ...     CONSTANTS.empty_attribute_default = None
         >>> name = HumanName("John Doe")
         >>> print(name.title)
         None
         >>> name.first
         'John'
-        >>> CONSTANTS.empty_attribute_default = ''
+        >>> with warnings.catch_warnings():
+        ...     warnings.simplefilter('ignore', DeprecationWarning)
+        ...     CONSTANTS.empty_attribute_default = ''
 
     """
 
@@ -805,13 +903,29 @@ class Constants:
         ]
         return "<Constants : [\n" + "\n".join(lines) + "\n]>"
 
+    def copy(self) -> 'Constants':
+        """
+        Return a detached deep copy of this ``Constants`` instance, preserving
+        its current customizations -- unlike :py:class:`Constants`'s own
+        constructor, which always starts from library defaults. Useful for
+        snapshotting the shared module-level ``CONSTANTS`` (including
+        whatever it's been customized with) into a private instance, e.g.
+        ``CONSTANTS.copy()``. Relies on the same ``__getstate__``/``__setstate__``
+        pair pickling uses, so it's as cheap and correct as pickle round-tripping.
+        """
+        return copy.deepcopy(self)
+
     def __setstate__(self, state: Mapping[str, Any]) -> None:
         # Restore each saved attribute directly. The previous implementation
         # passed the whole state dict to __init__ as the ``prefixes`` argument,
         # which silently reverted every collection to its module default on
         # unpickling.
         self._pst = None
+        legacy_format = False
         for name, value in state.items():
+            # inspect.getattr_static, not getattr, so descriptors are
+            # inspected directly rather than triggering their __get__.
+            descriptor = inspect.getattr_static(type(self), name, None)
             # Migration shim: pickles written before this fix (1.3.0 and earlier,
             # including 1.2.1) used a dir() sweep for __getstate__, so their state
             # carries the read-only ``suffixes_prefixes_titles`` property. Skip any
@@ -820,9 +934,29 @@ class Constants:
             # don't promise to read pre-fix blobs forever — this only smooths
             # migration for anyone persisting them, and can be dropped a release
             # or two after 1.3.0 once they've re-pickled.
-            if isinstance(getattr(type(self), name, None), property):
+            if isinstance(descriptor, property):
+                legacy_format = True
+                continue
+            if isinstance(descriptor, _EmptyAttributeDefaultAttribute):
+                # Bypass the descriptor's setter: restoring saved state isn't
+                # a user assignment, so it shouldn't emit #255's deprecation
+                # warning on every unpickle/copy() of a customized instance.
+                setattr(self, descriptor._attr, value)
                 continue
             setattr(self, name, value)
+        if legacy_format:
+            # Once per __setstate__ call, not once per skipped key (see
+            # issue #279): the 2.0 removal turns this into a ValueError
+            # naming the same fix.
+            warnings.warn(
+                "Loading a legacy-format Constants pickle (written by "
+                "nameparser <= 1.2.x, before the 1.3.0 pickle fix) is "
+                "deprecated and will raise ValueError in 2.0; re-pickle "
+                "under 1.3/1.4 to migrate. See "
+                "https://github.com/derek73/python-nameparser/issues/279",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         # Verify each descriptor-backed attr was restored. Without this, a missing
         # key surfaces later as AttributeError: 'Constants' object has no attribute
         # '_prefixes' — the private mangled name, not the public one, making it
@@ -847,7 +981,8 @@ class Constants:
         for name, val in self.__dict__.items():
             if name.startswith('_'):
                 public = name[1:]
-                if isinstance(getattr(type(self), public, None), _SetManagerAttribute):
+                descriptor = inspect.getattr_static(type(self), public, None)
+                if isinstance(descriptor, (_SetManagerAttribute, _EmptyAttributeDefaultAttribute)):
                     state[public] = val
             else:
                 state[name] = val

{nameparser-1.3.1 → nameparser-1.4.0}/nameparser/config/regexes.py

@@ -29,6 +29,10 @@ REGEXES = {
     "bidi": re_bidi,
     "phd": re.compile(r'\s(ph\.?\s+d\.?)', re.I),
     "space_before_comma": re.compile(r'\s+,'),
+    # ASCII comma plus its Arabic (U+060C) and fullwidth CJK (U+FF0C)
+    # counterparts, used to split "Last, First" format and to strip a
+    # trailing comma before parsing (#265).
+    "commas": re.compile(r'[,،，]'),
     "east_slavic_patronymic": re.compile(
         r'(ovich|ovna|evich|evna|ichna|ilyich|kuzmich|lukich|fomich|fokich)$',
         re.I,

{nameparser-1.3.1 → nameparser-1.4.0}/nameparser/parser.py

@@ -51,8 +51,14 @@ class HumanName:
     :param str full_name: The name string to be parsed.
     :param constants:
         a :py:class:`~nameparser.config.Constants` instance (subclasses are
-        honored). Pass ``None`` for `per-instance config <customize.html>`_.
-        Anything else raises ``TypeError``.
+        honored). Defaults to the shared module-level ``CONSTANTS``. For
+        `per-instance config <customize.html>`_, pass ``Constants()`` for
+        fresh library defaults, or ``CONSTANTS.copy()`` for a private
+        snapshot of the current shared config. Passing ``None`` also builds
+        a fresh ``Constants()``, but is deprecated (warns; raises
+        ``TypeError`` in 2.0, see issue #260) since it silently discards any
+        customizations the caller may have expected to carry over. Anything
+        else raises ``TypeError``.
     :param str encoding: string representing the encoding of your input
         (deprecated with ``bytes`` input, removal in 2.0 — decode before
         passing; see issue #245)
@@ -106,7 +112,10 @@ class HumanName:
         nickname: str | list[str] | None = None,
         maiden: str | list[str] | None = None,
     ) -> None:
-        self.C = constants
+        # calls _validate_constants directly (not through the C setter) so
+        # the deprecation warning below attributes to this constructor's
+        # caller rather than to the setter, mirroring _apply_full_name below
+        self._C = self._validate_constants(constants, stacklevel=3)
 
         # Lookup entries derived while parsing this instance (period-joined
         # titles/suffixes like "Lt.Gov.", conjunction-joined pieces like
@@ -143,11 +152,27 @@ class HumanName:
             self._apply_full_name(full_name, stacklevel=3)
 
     @staticmethod
-    def _validate_constants(constants: 'Constants | None') -> 'Constants':
+    def _validate_constants(constants: 'Constants | None', *, stacklevel: int) -> 'Constants':
         # Shared by the constructor and the C setter so both assignment paths
         # give the same immediate TypeError instead of one bypassing the
         # other and failing far from the cause (#239).
         if constants is None:
+            # deprecated 1.4.0, raises TypeError in 2.0 (#260, removal #261):
+            # None means "build a fresh private Constants()", the opposite of
+            # what None conventionally means (the default is the *shared*
+            # CONSTANTS) -- an easy trap since customizing CONSTANTS then
+            # passing None elsewhere silently drops those customizations with
+            # no error. CONSTANTS.copy() is the explicit spelling for the
+            # other reading: a private snapshot of the current shared config.
+            warnings.warn(
+                "Passing constants=None is deprecated and will raise "
+                "TypeError in 2.0; use constants=Constants() for fresh "
+                "library defaults, or constants=CONSTANTS.copy() to snapshot "
+                "the current shared config. See "
+                "https://github.com/derek73/python-nameparser/issues/260",
+                DeprecationWarning,
+                stacklevel=stacklevel,
+            )
             return Constants()
         if not isinstance(constants, Constants):
             # passing the class itself is the likeliest mistake, and
@@ -169,14 +194,16 @@ class HumanName:
         <customize.html>`_.
 
         Assigning a non-``Constants`` value (besides ``None``, which builds a
-        fresh private ``Constants()``) raises the same ``TypeError`` as passing
-        an invalid ``constants`` argument to the constructor (#239).
+        fresh private ``Constants()`` and emits a ``DeprecationWarning`` --
+        see :py:meth:`~nameparser.parser.HumanName.__init__`) raises the same
+        ``TypeError`` as passing an invalid ``constants`` argument to the
+        constructor (#239).
         """
         return self._C
 
     @C.setter
     def C(self, constants: 'Constants | None') -> None:
-        self._C = self._validate_constants(constants)
+        self._C = self._validate_constants(constants, stacklevel=3)
 
     def __getstate__(self) -> dict:
         state = self.__dict__.copy()
@@ -227,12 +254,38 @@ class HumanName:
     @overload
     def __getitem__(self, key: str) -> str: ...
     def __getitem__(self, key: slice | str) -> str | list[str]:
+        """
+        .. deprecated:: 1.4.0
+            Slice access (``name[1:-3]``) is removed in 2.0 (see issue
+            #258); field access by position has no real use case.
+            String-key access (``name['first']``) is unaffected.
+        """
         if isinstance(key, slice):
+            warnings.warn(
+                "Slicing a HumanName by position is deprecated and will be "
+                "removed in 2.0; access the named attributes instead. See "
+                "https://github.com/derek73/python-nameparser/issues/258",
+                DeprecationWarning,
+                stacklevel=2,
+            )
             return [getattr(self, x) for x in self._members[key]]
         else:
             return getattr(self, key)
 
     def __setitem__(self, key: str, value: str | list[str] | None) -> None:
+        """
+        .. deprecated:: 1.4.0
+            Removed in 2.0 (see issue #258); it duplicates plain attribute
+            assignment. Use ``name.first = value`` instead.
+        """
+        warnings.warn(
+            "HumanName item assignment is deprecated and will be removed "
+            "in 2.0; it duplicates plain attribute assignment, use "
+            "name.first = value instead. See "
+            "https://github.com/derek73/python-nameparser/issues/258",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         if key in self._members:
             self._set_list(key, value)
         else:
@@ -923,7 +976,7 @@ class HumanName:
     def collapse_whitespace(self, string: str) -> str:
         # collapse multiple spaces into single space
         string = self.C.regexes.spaces.sub(" ", string.strip())
-        if string.endswith(","):
+        if string and self.C.regexes.commas.fullmatch(string[-1]):
             string = string[:-1]
         return string
 
@@ -1195,8 +1248,14 @@ class HumanName:
 
         self._full_name = self.collapse_whitespace(self._full_name)
 
-        # break up full_name by commas
-        parts = [x.strip() for x in self._full_name.split(",")]
+        # break up full_name by commas. A missing "commas" key in a custom
+        # regexes dict falls back to RegexTupleManager's EMPTY_REGEX, whose
+        # .split() matches between every character rather than not
+        # splitting at all -- guard against that so a custom regexes dict
+        # that omits "commas" disables the comma split instead of shattering
+        # the name into single characters.
+        commas = self.C.regexes.commas
+        parts = [x.strip() for x in (commas.split(self._full_name) if commas.pattern else [self._full_name])]
         self._had_comma = len(parts) > 1
 
         log.debug("full_name: %s", self._full_name)

{nameparser-1.3.1 → nameparser-1.4.0/nameparser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 1.3.1
+Version: 1.4.0
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
 License: LGPL
@@ -31,8 +31,14 @@ Name Parser
 
 |Build Status| |PyPI| |PyPI version| |Documentation| |License| |Downloads| |Codecov|
 
+📣 **nameparser 2.0 is in design** — a new immutable core API, with full
+compatibility for existing code through 2.x. Read the `design RFC
+<https://github.com/derek73/python-nameparser/pull/285>`__ and share
+feedback on `the discussion issue
+<https://github.com/derek73/python-nameparser/issues/284>`__.
+
 A simple Python (3.10+) module for parsing human names into their
-individual components. 
+individual components.
 
 * hn.title
 * hn.first

{nameparser-1.3.1 → nameparser-1.4.0}/nameparser.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ tests/conftest.py
 tests/test_bound_first_names.py
 tests/test_brute_force.py
 tests/test_capitalization.py
+tests/test_comma_variants.py
 tests/test_config_attribute_docstrings.py
 tests/test_conjunctions.py
 tests/test_constants.py

{nameparser-1.3.1 → nameparser-1.4.0}/tests/conftest.py

@@ -1,4 +1,5 @@
 import copy
+import warnings
 from collections.abc import Iterator
 
 import pytest
@@ -60,9 +61,22 @@ def empty_attribute_default(request: pytest.FixtureRequest) -> Iterator[str | No
         attr: copy.deepcopy(getattr(CONSTANTS, attr))
         for attr in _COLLECTION_CONFIG_ATTRS
     }
-    CONSTANTS.empty_attribute_default = request.param
+    # empty_attribute_default assignment is deprecated (#255); this fixture's
+    # own systematic exercise of both settings across the whole suite is
+    # infrastructure, not a test of the deprecation itself, so it's silenced
+    # here (narrowly, around just the assignment) rather than at every one of
+    # its ~1500 call sites. Must not wrap `yield` -- that would suppress
+    # DeprecationWarning for the test body itself, hiding real ones.
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        CONSTANTS.empty_attribute_default = request.param
     yield request.param
     for attr, value in scalar_snapshot.items():
-        setattr(CONSTANTS, attr, value)
+        if attr == "empty_attribute_default":
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", DeprecationWarning)
+                setattr(CONSTANTS, attr, value)
+        else:
+            setattr(CONSTANTS, attr, value)
     for attr, value in collection_snapshot.items():
         setattr(CONSTANTS, attr, value)

nameparser-1.4.0/tests/test_comma_variants.py

@@ -0,0 +1,53 @@
+import pytest
+
+from nameparser import HumanName
+from nameparser.config import Constants
+from nameparser.config.regexes import REGEXES
+
+from tests.base import HumanNameTestBase
+
+
+class HumanNameCommaVariantsTests(HumanNameTestBase):
+    """Non-ASCII comma characters should split "Last, First" the same as ',' (#265)."""
+
+    def test_arabic_comma_splits_lastname_format(self) -> None:
+        hn = HumanName("سلمان، محمد")
+        self.m(hn.first, "محمد", hn)
+        self.m(hn.last, "سلمان", hn)
+
+    def test_fullwidth_comma_splits_lastname_format(self) -> None:
+        hn = HumanName("Smith，John")
+        self.m(hn.first, "John", hn)
+        self.m(hn.last, "Smith", hn)
+
+    def test_arabic_comma_does_not_pollute_output(self) -> None:
+        hn = HumanName("سلمان، محمد")
+        self.assertNotIn("،", hn.last)
+        self.assertNotIn("،", str(hn))
+
+    def test_trailing_arabic_comma_stripped(self) -> None:
+        # matches ASCII behavior: a single word with a trailing comma has
+        # nothing after the comma, so it's a bare name, not "Last,"
+        hn = HumanName("سلمان،")
+        self.m(hn.first, "سلمان", hn)
+
+    def test_custom_regexes_without_commas_key_does_not_shatter_name(self) -> None:
+        # A custom regexes dict that omits "commas" entirely must not fall
+        # back to RegexTupleManager's EMPTY_REGEX default for splitting --
+        # re.compile('').split(...) matches between every character, which
+        # explodes any name into single-char pieces instead of leaving it
+        # unsplit (the EMPTY_REGEX convention elsewhere in this codebase
+        # means "feature disabled", not "split on every character").
+        # With comma splitting disabled, "Smith, John" is tokenized like any
+        # other no-comma input (word tokenizing drops the punctuation),
+        # yielding a plain first/last pair -- not the inverted "Last, First"
+        # reading, and definitely not single-character pieces.
+        # Unknown-key access (here, the deliberately-omitted 'commas') is
+        # deprecated for removal in 2.0 (#256); this fallback pattern will
+        # AttributeError-crash the parser instead of degrading silently.
+        custom = {k: v for k, v in REGEXES.items() if k != 'commas'}
+        c = Constants(regexes=custom)
+        with pytest.deprecated_call():
+            hn = HumanName("Smith, John", constants=c)
+        self.m(hn.first, "Smith", hn)
+        self.m(hn.last, "John", hn)