Preserve weights through pickling and deepcopy

weights was a plain instance attribute, so it was absent from the pickle
state:

    pickle.loads(pickle.dumps(MicroSeries([1, 2], weights=[3, 4]))).sum()
    # AttributeError: 'MicroSeries' object has no attribute 'weights'

Declaring _metadata = ["weights"] fixes it: pandas includes _metadata
attributes in the pickle state.

MicroDataFrame needed one more step. Its weighted aggregations are
installed as per-instance closures by override_df_functions, which only
runs in __init__ — a path unpickling skips. So an unpickled frame kept
its weights but mdf.sum() fell through to the unweighted pandas
implementation and returned 6 instead of 14, with no error. __setstate__
now reinstalls them.

This covers the pickle half of #300; the _constructor rework that would
stop sort_values/fillna/sample from dropping weights is still open there.

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

Author: vahid-ahmadi

changelog.d/weights-metadata-pickle.yaml

@@ -0,0 +1,6 @@
+- bump: patch
+  changes:
+    fixed:
+    - Weights now survive pickling, to_pickle/read_pickle and copy.deepcopy;
+      previously they vanished, and an unpickled MicroDataFrame silently
+      returned unweighted aggregations.

microdf/microdataframe.py

@@ -95,6 +95,12 @@ def __getattr__(self, name):
 
 
 class MicroDataFrame(pd.DataFrame):
+    # Declare ``weights`` as pandas metadata. pandas includes
+    # _metadata attributes in the pickle state, so weights now survive
+    # pickling, to_pickle/read_pickle and copy.deepcopy instead of
+    # vanishing and leaving an AttributeError on the next aggregation.
+    _metadata = ["weights"]
+
     def __init__(self, *args, weights=None, **kwargs):
         """A DataFrame-inheriting class for weighted microdata.
 
@@ -110,6 +116,20 @@ def __init__(self, *args, weights=None, **kwargs):
         self._link_all_weights()
         self.override_df_functions()
 
+    def __setstate__(self, state) -> None:
+        """Restore a pickled MicroDataFrame.
+
+        The weighted aggregations are installed as per-instance closures by
+        ``override_df_functions``, which only runs in ``__init__`` — a path
+        unpickling skips. Without reinstalling them, ``mdf.sum()`` on an
+        unpickled frame silently fell through to the unweighted pandas
+        implementation.
+        """
+        super().__setstate__(state)
+        if getattr(self, "weights", None) is None:
+            self._link_all_weights()
+        self.override_df_functions()
+
     @property
     def loc(self) -> _MicroLocIndexer:
         """Label-based indexer that preserves MicroDataFrame type and weights.

microdf/microseries.py

@@ -50,6 +50,12 @@ def _weighted_top_share(
 
 
 class MicroSeries(pd.Series):
+    # Declare ``weights`` as pandas metadata. pandas includes
+    # _metadata attributes in the pickle state, so weights now survive
+    # pickling, to_pickle/read_pickle and copy.deepcopy instead of
+    # vanishing and leaving an AttributeError on the next aggregation.
+    _metadata = ["weights"]
+
     def __init__(self, *args, weights: np.array = None, **kwargs):
         """A Series-inheriting class for weighted microdata.
 

microdf/tests/test_microseries_dataframe.py

@@ -1,3 +1,4 @@
+import copy
 import warnings
 
 import numpy as np
@@ -815,3 +816,36 @@ def test_rank_ties_share_bucket() -> None:
     # existing ``test_rank`` expectations hold.
     s = mdf.MicroSeries([1, 2, 3], weights=[4, 5, 6])
     np.testing.assert_array_equal(s.rank().values, [4, 9, 15])
+
+
+def test_microseries_survives_pickling():
+    """Weights must survive a pickle round-trip."""
+    import pickle
+
+    s = mdf.MicroSeries([1, 2, 3], index=[7, 8, 9], weights=[1, 2, 3])
+    restored = pickle.loads(pickle.dumps(s))
+    assert isinstance(restored, mdf.MicroSeries)
+    assert restored.sum() == 14
+    assert list(restored.weights) == [1.0, 2.0, 3.0]
+
+
+def test_microdataframe_survives_pickling():
+    """Weights and the weighted aggregations must survive a round-trip."""
+    import pickle
+
+    df = mdf.MicroDataFrame(
+        pd.DataFrame({"x": [1, 2, 3]}, index=[7, 8, 9]), weights=[1, 2, 3]
+    )
+    restored = pickle.loads(pickle.dumps(df))
+    assert isinstance(restored, mdf.MicroDataFrame)
+    assert isinstance(restored.weights, pd.Series)
+    # Would be 6 (unweighted) if the aggregation overrides were not
+    # reinstalled after unpickling.
+    assert restored.sum()["x"] == 14
+
+
+def test_deepcopy_preserves_weights():
+    df = mdf.MicroDataFrame(pd.DataFrame({"x": [1, 2, 3]}), weights=[1, 2, 3])
+    assert copy.deepcopy(df).sum()["x"] == 14
+    s = mdf.MicroSeries([1, 2, 3], weights=[1, 2, 3])
+    assert copy.deepcopy(s).sum() == 14