efficient-did: make set_params atomic — rollback all attribute mutations on validation failure

Previously, EfficientDiD.set_params iterated over the kwargs and called
setattr() before invoking _validate_params(). A rejected batched call
such as set_params(vcov_type="classical", alpha=0.1, anticipation=2)
raised on validation but left every kwarg in the partially-mutated
state — the rejected vcov_type plus the otherwise-valid alpha and
anticipation. Callers that catch ValueError and continue using the
estimator would then operate on a silently corrupted parameter
configuration, defeating the eager-validation contract introduced when
_validate_vcov_type was wired into _validate_params.

Fix: snapshot original attribute values for every kwarg before applying
mutations, run validation, and on exception restore the snapshot before
re-raising. The snapshot pass also moves the "Unknown parameter" check
ahead of any mutation so that even unknown-name rejections leave the
estimator untouched.

Regression test added: test_set_params_rollback_on_validation_failure
fires the 3-kwarg batched call and pins all three attribute values to
their pre-call snapshot after the raise.

Author: igerber

diff_diff/efficient_did.py

@@ -351,13 +351,30 @@ def get_params(self) -> Dict[str, Any]:
         }
 
     def set_params(self, **params: Any) -> "EfficientDiD":
-        """Set estimator parameters (sklearn-compatible)."""
+        """Set estimator parameters (sklearn-compatible).
+
+        Atomic: snapshots the original attribute values before applying
+        mutations, validates the new state via ``_validate_params``, and
+        rolls every attribute back to its pre-call value if validation
+        raises. Without this, ``set_params(vcov_type="classical",
+        alpha=0.1)`` would leave ``self.vcov_type`` partially mutated
+        even though the call raised, defeating the eager-validation
+        contract for callers that catch ``ValueError`` and keep using
+        the estimator.
+        """
+        snapshot: Dict[str, Any] = {}
+        for key in params:
+            if not hasattr(self, key):
+                raise ValueError(f"Unknown parameter: {key}")
+            snapshot[key] = getattr(self, key)
         for key, value in params.items():
-            if hasattr(self, key):
+            setattr(self, key, value)
+        try:
+            self._validate_params()
+        except Exception:
+            for key, value in snapshot.items():
                 setattr(self, key, value)
-            else:
-                raise ValueError(f"Unknown parameter: {key}")
-        self._validate_params()
+            raise
         return self
 
     # -- Main estimation ------------------------------------------------------

tests/test_efficient_did.py

@@ -2521,6 +2521,24 @@ def test_set_params_unknown_vcov_caught_immediately(self):
         with pytest.raises(ValueError, match="hc4"):
             ed.set_params(vcov_type="hc4")
 
+    def test_set_params_rollback_on_validation_failure(self):
+        # set_params is atomic: when validation rejects a batched call, NO
+        # attribute mutation persists. Pre-fix, set_params assigned every
+        # kwarg before invoking _validate_params, so a rejected
+        # `set_params(vcov_type="classical", alpha=0.1, anticipation=2)`
+        # raised but left all three attributes mutated — weakening eager-
+        # validation for callers that catch ValueError and keep using the
+        # estimator.
+        ed = EfficientDiD()
+        original_vcov = ed.vcov_type
+        original_alpha = ed.alpha
+        original_anticipation = ed.anticipation
+        with pytest.raises(ValueError, match="influence-function"):
+            ed.set_params(vcov_type="classical", alpha=0.1, anticipation=2)
+        assert ed.vcov_type == original_vcov
+        assert ed.alpha == original_alpha
+        assert ed.anticipation == original_anticipation
+
     # ---- Surface 7: bootstrap n_psu<2 NaN propagation ---------------------
 
     def test_bootstrap_n_psu_less_than_2_returns_nan(self):