nameparser 1.2.0__tar.gz → 1.2.1__tar.gz

{nameparser-1.2.0 → nameparser-1.2.1}/MANIFEST.in

@@ -1,4 +1,4 @@
 include AUTHORS
 include LICENSE
 include README.rst
-include tests.py
+recursive-include tests *.py

{nameparser-1.2.0/nameparser.egg-info → nameparser-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 1.2.0
+Version: 1.2.1
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
 License: LGPL

nameparser-1.2.1/nameparser/__main__.py

@@ -0,0 +1,31 @@
+"""Command-line debug helper: parse a name and print the result.
+
+Usage:
+
+    python -m nameparser "Dr. Juan Q. Xavier de la Vega III"
+"""
+import logging
+import sys
+
+from nameparser import HumanName
+
+
+def main() -> None:
+    if len(sys.argv) <= 1:
+        print('Usage: python -m nameparser "Name String"')
+        raise SystemExit(1)
+    log = logging.getLogger('HumanName')
+    log.setLevel(logging.ERROR)
+    log.addHandler(logging.StreamHandler())
+    name_string = sys.argv[1]
+    hn = HumanName(name_string)
+    print(repr(hn))
+    hn.capitalize()
+    print(repr(hn))
+    # Use comma rather than concatenation: initials() returns
+    # empty_attribute_default (possibly None) when there are no initials.
+    print("Initials:", hn.initials())
+
+
+if __name__ == '__main__':
+    main()

{nameparser-1.2.0 → nameparser-1.2.1}/nameparser/_version.py

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

{nameparser-1.2.0 → nameparser-1.2.1}/nameparser/parser.py

@@ -273,17 +273,21 @@ class HumanName:
         middle_initials_list = [self.__process_initial__(name) for name in self.middle_list if name]
         last_initials_list = [self.__process_initial__(name) for name in self.last_list if name]
 
+        # Empty parts must render as '' (not empty_attribute_default, which may be
+        # None) so str.format does not interpolate the literal "None" into the
+        # output. A fully-empty result falls back to empty_attribute_default,
+        # matching the other attribute accessors (e.g. ``first``).
         initials_dict = {
             "first":  (self.initials_delimiter + " ").join(first_initials_list) + self.initials_delimiter
-            if len(first_initials_list) else self.C.empty_attribute_default,
+            if len(first_initials_list) else "",
             "middle": (self.initials_delimiter + " ").join(middle_initials_list) + self.initials_delimiter
-            if len(middle_initials_list) else self.C.empty_attribute_default,
+            if len(middle_initials_list) else "",
             "last": (self.initials_delimiter + " ").join(last_initials_list) + self.initials_delimiter
-            if len(last_initials_list) else self.C.empty_attribute_default
+            if len(last_initials_list) else ""
         }
 
         _s = self.initials_format.format(**initials_dict)
-        return self.collapse_whitespace(_s)
+        return self.collapse_whitespace(_s) or self.C.empty_attribute_default
 
     @property
     def has_own_config(self) -> bool:

{nameparser-1.2.0 → nameparser-1.2.1/nameparser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 1.2.0
+Version: 1.2.1
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
 License: LGPL

{nameparser-1.2.0 → nameparser-1.2.1}/nameparser.egg-info/SOURCES.txt

@@ -3,8 +3,8 @@ LICENSE
 MANIFEST.in
 README.rst
 pyproject.toml
-tests.py
 nameparser/__init__.py
+nameparser/__main__.py
 nameparser/_version.py
 nameparser/parser.py
 nameparser/py.typed
@@ -20,4 +20,20 @@ nameparser/config/conjunctions.py
 nameparser/config/prefixes.py
 nameparser/config/regexes.py
 nameparser/config/suffixes.py
-nameparser/config/titles.py
+nameparser/config/titles.py
+tests/__init__.py
+tests/base.py
+tests/conftest.py
+tests/test_brute_force.py
+tests/test_capitalization.py
+tests/test_conjunctions.py
+tests/test_constants.py
+tests/test_first_name.py
+tests/test_initials.py
+tests/test_nicknames.py
+tests/test_output_format.py
+tests/test_prefixes.py
+tests/test_python_api.py
+tests/test_suffixes.py
+tests/test_titles.py
+tests/test_variations.py

{nameparser-1.2.0 → nameparser-1.2.1}/pyproject.toml

@@ -39,6 +39,7 @@ nameparser = ["py.typed"]
 
 [dependency-groups]
 dev = [
+  "pytest (>=8)",
   "dill (>=0.2.5)",
   "sphinx (>=8)",
   "mypy (>=2.1)",
@@ -54,6 +55,13 @@ module = [
 ]
 ignore_missing_imports = true
 
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_classes = ["*Tests", "*TestCase"]
+# Fail if an xfail-marked test unexpectedly passes, so a fixed/regressed
+# expectation surfaces instead of silently turning into an xpass.
+xfail_strict = true
+
 [tool.ruff.lint]
 extend-select = [
   "ANN",   # flake8-annotations

nameparser-1.2.1/tests/base.py

@@ -0,0 +1,40 @@
+from typing import Generic, TypeVar
+
+from nameparser import HumanName
+
+T = TypeVar('T')
+
+
+class HumanNameTestBase(Generic[T]):
+    """Shared assert helpers for the parsing tests.
+
+    Formerly subclassed unittest.TestCase. It is now a plain class so pytest can
+    apply the parametrized dual-run fixture in conftest.py — parametrized
+    fixtures do not apply to unittest.TestCase subclasses. The assert* methods
+    are thin shims so existing test bodies move over unchanged.
+    """
+
+    def m(self, actual: T, expected: T, hn: HumanName) -> None:
+        """assertEqual with a better message and awareness of hn.C.empty_attribute_default"""
+        expected_ = expected or hn.C.empty_attribute_default
+        try:
+            assert actual == expected_, "'%s' != '%s' for '%s'\n%r" % (
+                actual,
+                expected,
+                hn.original,
+                hn,
+            )
+        except UnicodeDecodeError:
+            assert actual == expected_
+
+    def assertEqual(self, first: object, second: object, msg: object = None) -> None:
+        assert first == second, msg
+
+    def assertTrue(self, expr: object, msg: object = None) -> None:
+        assert expr, msg
+
+    def assertFalse(self, expr: object, msg: object = None) -> None:
+        assert not expr, msg
+
+    def assertIn(self, member: object, container: object, msg: object = None) -> None:
+        assert member in container, msg  # type: ignore[operator]

nameparser-1.2.1/tests/conftest.py

@@ -0,0 +1,80 @@
+from collections.abc import Iterator
+
+import pytest
+
+from nameparser.config import CONSTANTS, SetManager, TupleManager
+
+ConfigCollection = SetManager | TupleManager
+
+# Scalar (non-collection) config attributes that individual tests mutate on the
+# global CONSTANTS singleton. Several tests change these without restoring them;
+# the original suite only survived because unittest happens to run methods in
+# alphabetical order, so a later test reset the value. pytest runs in definition
+# order, so we snapshot and restore these around every test to keep tests
+# isolated regardless of order.
+_SCALAR_CONFIG_ATTRS = (
+    "empty_attribute_default",
+    "string_format",
+    "initials_format",
+    "initials_delimiter",
+    "capitalize_name",
+    "force_mixed_case_capitalization",
+)
+
+# Collection config attributes (the SetManager / TupleManager constants). Tests
+# that customize the global CONSTANTS — e.g. adding or removing a title — mutate
+# these in place, so a shallow snapshot of the reference would not protect later
+# tests. We snapshot independent copies and restore them, making collection
+# mutations order-independent too.
+_COLLECTION_CONFIG_ATTRS = (
+    "prefixes",
+    "suffix_acronyms",
+    "suffix_not_acronyms",
+    "titles",
+    "first_name_titles",
+    "conjunctions",
+    "capitalization_exceptions",
+    "regexes",
+)
+
+
+def _clone_config_collection(value: ConfigCollection) -> ConfigCollection:
+    """Return an independent copy of a config collection manager.
+
+    ``copy.deepcopy`` is not used because ``RegexTupleManager`` carries compiled
+    patterns that its ``__reduce__`` cannot round-trip. Rebuilding from the
+    manager's own contents copies the container while sharing the (immutable)
+    elements, which is all the snapshot needs.
+    """
+    if isinstance(value, SetManager):
+        return SetManager(set(value))
+    # TupleManager / RegexTupleManager are dict subclasses.
+    return type(value)(dict(value))
+
+
+@pytest.fixture(autouse=True, params=['', None], ids=['default', 'none'])
+def empty_attribute_default(request: pytest.FixtureRequest) -> Iterator[str | None]:
+    """Run every test under both empty_attribute_default settings, isolating global config.
+
+    Reproduces the original tests.py __main__ block, which ran the whole suite
+    twice — once with the default ('') and once with None — as a regression
+    check that the three parsing code paths agree. The surrounding snapshot of
+    both the scalar and the collection CONSTANTS attributes restores any global
+    config a test mutates, so tests do not leak state into one another (the
+    original relied on unittest's alphabetical method ordering to mask such
+    leaks).
+    """
+    scalar_snapshot = {attr: getattr(CONSTANTS, attr) for attr in _SCALAR_CONFIG_ATTRS}
+    collection_snapshot = {
+        attr: _clone_config_collection(getattr(CONSTANTS, attr))
+        for attr in _COLLECTION_CONFIG_ATTRS
+    }
+    CONSTANTS.empty_attribute_default = request.param
+    yield request.param
+    for attr, value in scalar_snapshot.items():
+        setattr(CONSTANTS, attr, value)
+    for attr, value in collection_snapshot.items():
+        setattr(CONSTANTS, attr, value)
+    # Invalidate the lazily-built suffixes/prefixes/titles cache so it is
+    # recomputed from the restored collections rather than a mutated one.
+    CONSTANTS._pst = None