Enforce the pickle guards mechanically; flatten test imports

Forgetting the two class-body guard assignments on a future frozen
type is silent -- @DataClass(slots=True) installs its own working
pickle methods without skew detection. A conventions test now
enumerates every frozen dataclass in the package and asserts the
guards are present (Lexicon allow-listed for its private copy),
turning a per-class convention into a CI gate. Also folds five
vestigial function-local render imports into the top import block.

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

Author: derek73

tests/v2/test_layering.py

@@ -1,4 +1,5 @@
-"""Enforce the conventions doc's import layering mechanically."""
+"""Enforce the conventions doc's contracts mechanically: import
+layering, public exports, and the pickle layout guards."""
 import ast
 import pathlib
 
@@ -108,3 +109,33 @@ def test_type_checking_imports_do_not_count(tmp_path: pathlib.Path) -> None:
         "    from nameparser import _render\n"
     )
     assert _nameparser_imports(mod) == ["nameparser.util", "nameparser"]
+
+
+def test_every_frozen_dataclass_carries_the_pickle_guards() -> None:
+    # Forgetting the two class-body assignments is SILENT --
+    # @dataclass(slots=True) installs its own working pickle methods
+    # without skew detection. Lexicon keeps a private copy of the guard
+    # (layering keeps _lexicon import-free of _types).
+    import dataclasses
+    import inspect
+
+    import nameparser._lexicon
+    import nameparser._locale
+    import nameparser._policy
+    import nameparser._types
+    from nameparser._types import _guarded_getstate, _guarded_setstate
+
+    modules = (nameparser._types, nameparser._lexicon,
+               nameparser._policy, nameparser._locale)
+    for module in modules:
+        for _, cls in inspect.getmembers(module, inspect.isclass):
+            if cls.__module__ != module.__name__:
+                continue
+            if not dataclasses.is_dataclass(cls):
+                continue
+            if cls.__name__ == "Lexicon":
+                assert "__getstate__" in cls.__dict__
+                assert "__setstate__" in cls.__dict__
+                continue
+            assert cls.__dict__.get("__getstate__") is _guarded_getstate, cls
+            assert cls.__dict__.get("__setstate__") is _guarded_setstate, cls

tests/v2/test_render.py

@@ -1,7 +1,7 @@
 import pytest
 
 from nameparser._lexicon import Lexicon
-from nameparser._render import _collapse
+from nameparser._render import _collapse, render
 from nameparser._types import Ambiguity, AmbiguityKind, ParsedName, Role, Span, Token
 
 
@@ -40,7 +40,6 @@ def _delavega() -> ParsedName:
 
 
 def test_render_fills_fields_and_collapses() -> None:
-    from nameparser._render import render
     pn = _delavega()
     assert render(pn, "{title} {given} {middle} {family} {suffix}") \
         == "Dr. Juan de la Vega III"
@@ -49,28 +48,24 @@ def test_render_fills_fields_and_collapses() -> None:
 
 
 def test_render_accepts_derived_view_keys() -> None:
-    from nameparser._render import render
     assert render(_delavega(), "{family_base}, {given} {family_particles}") \
         == "Vega, Juan de la"
     assert render(_delavega(), "{surnames}") == "de la Vega"
     assert render(_delavega(), "{given_names}") == "Juan"
 
 
 def test_render_every_role_key_is_valid() -> None:
-    from nameparser._render import render
     pn = _delavega()
     for role in Role:
         render(pn, f"{{{role.value}}}")  # must not raise
 
 
 def test_render_unknown_key_raises_enriched_keyerror() -> None:
-    from nameparser._render import render
     with pytest.raises(KeyError, match="valid fields"):
         render(_delavega(), "{first}")  # v1 spelling: redirected loudly
 
 
 def test_render_empty_parse_is_empty_string() -> None:
-    from nameparser._render import render
     assert render(_pn("", []), "{title} {given} {middle} {family} {suffix}") == ""