Address review P2s: snippet guard, pickle snapshot drop

- Practitioner LOO snippet now guards on `_loo_unit_ids` availability,
  not just variance_method. Single-treated-unit and single-effective-
  control designs legitimately return empty jackknife output; a user
  copy-pasting the prior snippet would hit a ValueError from
  get_loo_effects_df(). The else branch now describes the actual
  requirements.
- SyntheticDiDResults.__getstate__ drops _fit_snapshot on pickle so
  generic pickle.dumps() no longer carries outcome matrices, unit IDs,
  or survey weights to wherever the pickled bytes are sent. The live
  session is unaffected; unpickled results raise the existing "re-fit
  to enable" message from in_time_placebo / sensitivity_to_zeta_omega.

Tests cover:
- Snippet degrades gracefully on single-treated jackknife fit
  (exec()'s the snippet, asserts the "LOO not available" message).
- Pickle round-trip drops the snapshot and leaves public fields intact.
- in_time_placebo / sensitivity_to_zeta_omega raise after unpickle.
- __getstate__ does not mutate the live instance's snapshot.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: igerber

diff_diff/practitioner.py

@@ -545,11 +545,15 @@ def _handle_synthetic(results: Any):
                 "which units move the ATT the most."
             ),
             code=(
-                "if results.variance_method == 'jackknife':\n"
+                "# Requires variance_method='jackknife' AND enough support for LOO\n"
+                "# (n_treated >= 2 and >= 2 effective-weight controls).\n"
+                "if getattr(results, '_loo_unit_ids', None) is not None:\n"
                 "    loo_df = results.get_loo_effects_df()\n"
                 "    print(loo_df.head(10))\n"
                 "else:\n"
-                "    print('Re-fit with variance_method=\"jackknife\" to see LOO.')"
+                "    print('LOO not available - re-fit with '\n"
+                "          'variance_method=\"jackknife\" and ensure >=2 treated units '\n"
+                "          'with positive effective support.')"
             ),
             priority="medium",
             step_name="sensitivity",

diff_diff/results.py

@@ -793,6 +793,23 @@ def __repr__(self) -> str:
             f"p={self.p_value:.4f})"
         )
 
+    def __getstate__(self) -> Dict[str, Any]:
+        """Exclude the internal fit snapshot from pickling.
+
+        The snapshot retains outcome matrices, unit IDs, and survey weights
+        to support post-hoc diagnostics (`in_time_placebo`,
+        `sensitivity_to_zeta_omega`). Serialization would otherwise carry
+        that panel state to wherever the pickle is sent, which is a privacy
+        hazard for survey-weighted or sensitive fits.
+
+        Unpickled results keep the public fields (ATT, weights, trajectories,
+        etc.); calling a diagnostic method that needs the snapshot raises a
+        ValueError directing the user to re-fit.
+        """
+        state = self.__dict__.copy()
+        state["_fit_snapshot"] = None
+        return state
+
     @property
     def coef_var(self) -> float:
         """Coefficient of variation: SE / |ATT|. NaN when ATT is 0 or SE non-finite."""

tests/test_methodology_sdid.py

@@ -1994,3 +1994,85 @@ def test_snippets_parse_as_python(self):
         steps, _ = _handle_synthetic(res)
         for step in steps:
             ast.parse(step["code"])
+
+    def test_jackknife_loo_snippet_handles_unavailable_loo(self):
+        """When variance_method='jackknife' but LOO is unavailable
+        (e.g., n_treated=1 returns empty jackknife array), the LOO snippet
+        should degrade gracefully instead of raising."""
+        from diff_diff.practitioner import _handle_synthetic
+
+        df = _make_panel(n_control=10, n_treated=1, n_pre=5, n_post=3, seed=97)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            sdid = SyntheticDiD(variance_method="jackknife", seed=97)
+            res = sdid.fit(df, outcome="outcome", treatment="treated",
+                           unit="unit", time="period",
+                           post_periods=list(range(5, 8)))
+        assert res.variance_method == "jackknife"
+        assert res._loo_unit_ids is None  # LOO intentionally unavailable
+
+        steps, _ = _handle_synthetic(res)
+        loo_snippet = next(
+            s["code"] for s in steps if "get_loo_effects_df" in s["code"]
+        )
+        # Executing the snippet against this result must not raise.
+        import io
+        import contextlib
+        captured = io.StringIO()
+        with contextlib.redirect_stdout(captured):
+            exec(loo_snippet, {"results": res})
+        assert "LOO not available" in captured.getvalue()
+
+
+class TestSyntheticDiDResultsPickle:
+    """Pickle round-trip drops the fit snapshot; diagnostic methods raise
+    with the documented recovery message."""
+
+    def _fit(self, seed=101):
+        df = _make_panel(seed=seed)
+        sdid = SyntheticDiD(variance_method="jackknife", seed=seed)
+        return sdid.fit(df, outcome="outcome", treatment="treated",
+                        unit="unit", time="period")
+
+    def test_snapshot_dropped_on_pickle(self):
+        import pickle
+
+        res = self._fit()
+        assert res._fit_snapshot is not None  # present pre-pickle
+
+        restored = pickle.loads(pickle.dumps(res))
+        assert restored._fit_snapshot is None
+        # Public fields survive
+        assert restored.att == res.att
+        assert restored.se == res.se
+        assert np.allclose(
+            restored.synthetic_pre_trajectory, res.synthetic_pre_trajectory
+        )
+
+    def test_in_time_placebo_raises_after_pickle(self):
+        import pickle
+
+        res = self._fit(seed=103)
+        restored = pickle.loads(pickle.dumps(res))
+        with pytest.raises(ValueError, match="fit snapshot"):
+            restored.in_time_placebo()
+
+    def test_sensitivity_raises_after_pickle(self):
+        import pickle
+
+        res = self._fit(seed=105)
+        restored = pickle.loads(pickle.dumps(res))
+        with pytest.raises(ValueError, match="fit snapshot"):
+            restored.sensitivity_to_zeta_omega()
+
+    def test_live_instance_snapshot_untouched_by_getstate(self):
+        """__getstate__ must not mutate the live object's snapshot —
+        only the returned state dict carries the nulled field."""
+        res = self._fit(seed=107)
+        snap_before = res._fit_snapshot
+        assert snap_before is not None
+        _ = res.__getstate__()
+        # Live instance unchanged after __getstate__ call
+        assert res._fit_snapshot is snap_before
+        # Diagnostics still work in the live session
+        _ = res.in_time_placebo(fake_treatment_periods=[2])