Compare default values in the stub-drift test

The stub-drift test compared only method and parameter names, so a
default changed on one side only (the Rust pyo3 signature or the type
stub) would pass CI while type checkers report the wrong default.
The prefer_meters_in_component_formulas flip is exactly this kind of
change. Add a test that compares the __init__ default values from the
stub AST against the runtime signature. Defaults that are not plain
literals are marked and fail the comparison loudly; classes without an
introspectable runtime signature are skipped, as in the name test.

Signed-off-by: Sahas Subramanian <sahas.subramanian@proton.me>

Author: shsms

tests/test_stub_drift.py

@@ -83,3 +83,71 @@ def test_stub_and_runtime_init_params_agree() -> None:
             f"  stub:    {stub_params}\n"
             f"  runtime: {runtime_params}"
         )
+
+
+_NON_LITERAL = "<non-literal stub default>"
+
+
+def _literal_or_marker(node: ast.expr) -> object:
+    """Evaluate a stub default, or return the ``_NON_LITERAL`` marker."""
+    try:
+        return ast.literal_eval(node)
+    except ValueError:
+        return _NON_LITERAL
+
+
+def _parse_stub_init_defaults() -> dict[str, dict[str, object]]:
+    """Parse the stub into ``{ClassName: {param_name: default_value}}``.
+
+    Only ``__init__`` parameters with a default are included. A default
+    that is not a plain literal (like ``False`` or ``None``) is stored as
+    the ``_NON_LITERAL`` marker; it never equals a runtime value, so a
+    comparison against it fails loudly.
+    """
+    tree = ast.parse(_STUB_PATH.read_text())
+    out: dict[str, dict[str, object]] = {}
+    for node in tree.body:
+        if not isinstance(node, ast.ClassDef):
+            continue
+        for item in node.body:
+            if not isinstance(item, ast.FunctionDef) or item.name != "__init__":
+                continue
+            args = item.args
+            defaults: dict[str, object] = {}
+            for arg, default in zip(args.args[-len(args.defaults) :], args.defaults):
+                defaults[arg.arg] = _literal_or_marker(default)
+            for kwarg, kw_default in zip(args.kwonlyargs, args.kw_defaults):
+                if kw_default is not None:
+                    defaults[kwarg.arg] = _literal_or_marker(kw_default)
+            out[node.name] = defaults
+    return out
+
+
+def test_stub_and_runtime_init_defaults_agree() -> None:
+    """`__init__` default values in the stub must match the runtime signature.
+
+    The parameter-name test above can not catch a default changed on only
+    one side -- for example a flag like `prefer_meters_in_component_formulas`
+    flipped in the Rust `#[pyo3(signature = ...)]` but not in the stub.
+    Type checkers and IDEs would then report the wrong default for a flag
+    that inverts behavior.
+
+    Skips classes where the runtime signature is not introspectable, like
+    the name test above.
+    """
+    stub_defaults = _parse_stub_init_defaults()
+    for cls in _PUBLIC_RUNTIME_CLASSES:
+        try:
+            runtime_sig = inspect.signature(cls)
+        except ValueError:
+            continue
+        runtime_defaults = {
+            name: param.default
+            for name, param in runtime_sig.parameters.items()
+            if param.default is not inspect.Parameter.empty
+        }
+        assert stub_defaults.get(cls.__name__, {}) == runtime_defaults, (
+            f"{cls.__name__}.__init__ default drift:\n"
+            f"  stub:    {stub_defaults.get(cls.__name__, {})}\n"
+            f"  runtime: {runtime_defaults}"
+        )