microdf-python 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

microdf/microdataframe.py

@@ -278,18 +278,18 @@ class MicroDataFrame(pd.DataFrame):
         self._link_all_weights()
 
     def _link_weights(self, column) -> None:
-        # self[column] = ... triggers __setitem__, which forces pd.Series
-        # this workaround avoids that
-        self[column].__class__ = MicroSeries
-        self[column].set_weights(self.weights)
+        # In pandas 3.0+, we can't modify column classes in-place due to CoW.
+        # Instead, we rely on __getitem__ to wrap columns as MicroSeries on
+        # access. This method is kept for backward compatibility but is now
+        # a no-op.
+        pass
 
     def _link_all_weights(self) -> None:
         if self.weights is None:
             if len(self) > 0:
                 self.set_weights(np.ones((len(self))))
-        for column in self.columns:
-            if column != self.weights_col:
-                self._link_weights(column)
+        # In pandas 3.0+, columns are wrapped as MicroSeries on access via
+        # __getitem__, not stored as MicroSeries internally.
 
     def set_weights(
         self,
@@ -365,7 +365,7 @@ class MicroDataFrame(pd.DataFrame):
 
     def __getitem__(
         self, key: Union[str, List]
-    ) -> Union[pd.Series, pd.DataFrame]:
+    ) -> Union[MicroSeries, "MicroDataFrame"]:
         # Let pandas handle the initial slicing
         result = super().__getitem__(key)
 
@@ -374,17 +374,22 @@ class MicroDataFrame(pd.DataFrame):
             new_weights = self.weights.reindex(result.index)
             return MicroDataFrame(result, weights=new_weights)
 
-        # Otherwise, the result is a Series or a scalar, so just return it
+        # If the result is a Series (single column), wrap as MicroSeries
+        if isinstance(result, pd.Series):
+            return MicroSeries(result, weights=self.weights)
+
+        # Otherwise, the result is a scalar, so just return it
         return result
 
     def catch_series_relapse(self) -> None:
-        for col in self.columns:
-            if self[col].__class__ == pd.Series:
-                self._link_weights(col)
+        # In pandas 3.0+, we don't need to track series class changes since
+        # __getitem__ always wraps columns as MicroSeries on access.
+        pass
 
     def __setattr__(self, key, value) -> None:
         super().__setattr__(key, value)
-        self.catch_series_relapse()
+        # No need to call catch_series_relapse in pandas 3.0+ since we wrap
+        # on access rather than store MicroSeries internally.
 
     def reset_index(
         self,

microdf/microseries.py

@@ -1,4 +1,5 @@
 import logging
+import warnings
 from functools import wraps
 from typing import Callable, List, Optional, Union
 
@@ -19,6 +20,50 @@ class MicroSeries(pd.Series):
         super().__init__(*args, **kwargs)
         self.set_weights(weights)
 
+    @property
+    def _values(self):
+        """Internal access to underlying numpy array without warning."""
+        return super().values
+
+    @property
+    def values(self):
+        """Access underlying numpy array.
+
+        .. warning::
+            Returns a plain numpy array without weights. Operations
+            like ``.mean()`` on the result will be unweighted. Use
+            MicroSeries methods directly for weighted calculations
+            (e.g., ``ms.mean()`` instead of ``ms.values.mean()``).
+        """
+        warnings.warn(
+            "Accessing .values on a MicroSeries returns a plain numpy "
+            "array without weights. Operations like .mean() on the "
+            "result will be unweighted. Use MicroSeries methods "
+            "directly for weighted calculations (e.g., ms.mean() "
+            "instead of ms.values.mean()).",
+            UserWarning,
+            stacklevel=2,
+        )
+        return super().values
+
+    def to_numpy(self, *args, **kwargs):
+        """Convert to numpy array.
+
+        .. warning::
+            Returns a plain numpy array without weights. Operations
+            like ``.mean()`` on the result will be unweighted. Use
+            MicroSeries methods directly for weighted calculations.
+        """
+        warnings.warn(
+            "Calling .to_numpy() on a MicroSeries returns a plain "
+            "numpy array without weights. Operations like .mean() on "
+            "the result will be unweighted. Use MicroSeries methods "
+            "directly for weighted calculations.",
+            UserWarning,
+            stacklevel=2,
+        )
+        return super().to_numpy(*args, **kwargs)
+
     def weighted_function(fn: Callable) -> Callable:
         @wraps(fn)
         def safe_fn(*args, **kwargs):
@@ -52,7 +97,7 @@ class MicroSeries(pd.Series):
         if weights is None:
             if len(self) > 0:
                 self.weights = pd.Series(
-                    np.ones_like(self.values), dtype=float
+                    np.ones_like(self._values), dtype=float
                 )
         else:
             if len(weights) != len(self):
@@ -110,7 +155,7 @@ class MicroSeries(pd.Series):
         :returns: The weighted mean.
         :rtype: float
         """
-        values = self.values
+        values = self._values
         weights = self.weights
 
         if skipna:
@@ -141,7 +186,7 @@ class MicroSeries(pd.Series):
         :return: Weighted quantile value(s).
         :rtype: float or pd.Series
         """
-        values = np.array(self.values)
+        values = np.array(self._values)
         quantiles = np.atleast_1d(q)
         sample_weight = np.array(self.weights)
         assert np.all(quantiles >= 0) and np.all(
@@ -313,7 +358,7 @@ class MicroSeries(pd.Series):
                 "in division by zero."
             )
 
-        order = np.argsort(self.values)
+        order = np.argsort(self._values)
         inverse_order = np.argsort(order)
         ranks = np.array(self.weights.values)[order].cumsum()[inverse_order]
         if pct:
@@ -506,7 +551,7 @@ class MicroSeries(pd.Series):
         return MicroSeries(super().__rxor__(other), weights=self.weights)
 
     def sqrt(self) -> "MicroSeries":
-        sqrt_values = np.sqrt(self.values)
+        sqrt_values = np.sqrt(self._values)
         return MicroSeries(sqrt_values, index=self.index, weights=self.weights)
 
     # comparators
@@ -590,7 +635,7 @@ class MicroSeries(pd.Series):
 
     def __repr__(self) -> str:
         return pd.DataFrame(
-            dict(value=self.values, weight=self.weights.values)
+            dict(value=self._values, weight=self.weights.values)
         ).__repr__()
 
 

microdf/tests/test_microseries_dataframe.py

@@ -1,3 +1,5 @@
+import warnings
+
 import numpy as np
 import pandas as pd
 
@@ -423,3 +425,45 @@ def test_groupby_column_selection() -> None:
     result_all = d.groupby("g").sum()
     assert "weight" not in result_all.columns
     assert list(result_all.columns) == ["y"]
+
+
+def test_values_warns() -> None:
+    """Accessing .values on a MicroSeries should emit a UserWarning."""
+    ms = mdf.MicroSeries([1, 2, 3], weights=[4, 5, 6])
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = ms.values
+        assert len(w) == 1
+        assert issubclass(w[0].category, UserWarning)
+        assert "weights" in str(w[0].message).lower()
+
+
+def test_to_numpy_warns() -> None:
+    """Calling .to_numpy() on a MicroSeries should emit a UserWarning."""
+    ms = mdf.MicroSeries([1, 2, 3], weights=[4, 5, 6])
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = ms.to_numpy()
+        assert len(w) == 1
+        assert issubclass(w[0].category, UserWarning)
+        assert "weights" in str(w[0].message).lower()
+
+
+def test_mean_no_warning() -> None:
+    """Internal .values usage in .mean() should NOT emit a warning."""
+    ms = mdf.MicroSeries([1, 2, 3], weights=[4, 5, 6])
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = ms.mean()
+        user_warnings = [x for x in w if issubclass(x.category, UserWarning)]
+        assert len(user_warnings) == 0
+
+
+def test_repr_no_warning() -> None:
+    """Internal .values usage in __repr__ should NOT emit a warning."""
+    ms = mdf.MicroSeries([1, 2, 3], weights=[4, 5, 6])
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = repr(ms)
+        user_warnings = [x for x in w if issubclass(x.category, UserWarning)]
+        assert len(user_warnings) == 0

microdf/tests/test_pandas3_compatibility.py

@@ -1,5 +1,4 @@
-"""
-Tests for pandas 3.0.0 compatibility in microdf.
+"""Tests for pandas 3.0.0 compatibility in microdf.
 
 These tests verify that microdf works correctly with pandas 3.0.0,
 which introduces:
@@ -10,18 +9,17 @@ which introduces:
 
 import numpy as np
 import pandas as pd
-import pytest
 
-from microdf.microseries import MicroSeries
 from microdf.microdataframe import MicroDataFrame
+from microdf.microseries import MicroSeries
 
 
 class TestMicroSeriesSubclassPreservation:
     """Test that MicroSeries subclass is preserved across operations."""
 
     def test_microseries_set_weights_after_creation(self):
-        """
-        Ensure set_weights works on MicroSeries.
+        """Ensure set_weights works on MicroSeries.
+
         This is the error reported in pandas 3:
         AttributeError: 'Series' object has no attribute 'set_weights'
         """
@@ -34,86 +32,97 @@ class TestMicroSeriesSubclassPreservation:
         assert np.allclose(ms.weights, [2.0, 2.0, 2.0])
 
     def test_microseries_preserved_after_arithmetic(self):
-        """
-        Arithmetic operations should return MicroSeries, not plain Series.
-        """
+        """Arithmetic operations should return MicroSeries, not plain
+        Series."""
         ms = MicroSeries([1, 2, 3], weights=np.array([1.0, 2.0, 3.0]))
 
         # Addition
         result = ms + 1
-        assert isinstance(result, MicroSeries), f"Got {type(result)} instead of MicroSeries"
+        assert isinstance(
+            result, MicroSeries
+        ), f"Got {type(result)} instead of MicroSeries"
         assert hasattr(result, "weights")
         assert hasattr(result, "set_weights")
 
         # Multiplication
         result = ms * 2
-        assert isinstance(result, MicroSeries), f"Got {type(result)} instead of MicroSeries"
+        assert isinstance(
+            result, MicroSeries
+        ), f"Got {type(result)} instead of MicroSeries"
 
         # Division
         result = ms / 2
-        assert isinstance(result, MicroSeries), f"Got {type(result)} instead of MicroSeries"
+        assert isinstance(
+            result, MicroSeries
+        ), f"Got {type(result)} instead of MicroSeries"
 
     def test_microseries_preserved_after_comparison(self):
-        """
-        Comparison operations should return MicroSeries, not plain Series.
-        """
+        """Comparison operations should return MicroSeries, not plain
+        Series."""
         ms = MicroSeries([1, 2, 3], weights=np.array([1.0, 2.0, 3.0]))
 
         # Greater than
         result = ms > 1
-        assert isinstance(result, MicroSeries), f"Got {type(result)} instead of MicroSeries"
+        assert isinstance(
+            result, MicroSeries
+        ), f"Got {type(result)} instead of MicroSeries"
         assert hasattr(result, "weights")
 
         # Less than
         result = ms < 3
-        assert isinstance(result, MicroSeries), f"Got {type(result)} instead of MicroSeries"
+        assert isinstance(
+            result, MicroSeries
+        ), f"Got {type(result)} instead of MicroSeries"
 
     def test_microseries_preserved_after_indexing(self):
-        """
-        Indexing operations should return MicroSeries, not plain Series.
-        """
-        ms = MicroSeries([1, 2, 3, 4, 5], weights=np.array([1.0, 2.0, 3.0, 4.0, 5.0]))
+        """Indexing operations should return MicroSeries, not plain Series."""
+        ms = MicroSeries(
+            [1, 2, 3, 4, 5], weights=np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        )
 
         # Boolean indexing
         result = ms[ms > 2]
-        assert isinstance(result, MicroSeries), f"Got {type(result)} instead of MicroSeries"
+        assert isinstance(
+            result, MicroSeries
+        ), f"Got {type(result)} instead of MicroSeries"
         assert hasattr(result, "weights")
 
         # Slice indexing
         result = ms[1:3]
-        assert isinstance(result, MicroSeries), f"Got {type(result)} instead of MicroSeries"
+        assert isinstance(
+            result, MicroSeries
+        ), f"Got {type(result)} instead of MicroSeries"
 
 
 class TestMicroDataFrameSubclassPreservation:
     """Test that MicroDataFrame column access returns MicroSeries."""
 
     def test_microdataframe_column_returns_microseries(self):
-        """
-        Accessing a column from MicroDataFrame should return MicroSeries.
-        """
+        """Accessing a column from MicroDataFrame should return MicroSeries."""
         mdf = MicroDataFrame(
-            {"a": [1, 2, 3], "b": [4, 5, 6]},
-            weights=np.array([1.0, 2.0, 3.0])
+            {"a": [1, 2, 3], "b": [4, 5, 6]}, weights=np.array([1.0, 2.0, 3.0])
         )
 
         # Column access
         col = mdf["a"]
-        assert isinstance(col, MicroSeries), f"Got {type(col)} instead of MicroSeries"
+        assert isinstance(
+            col, MicroSeries
+        ), f"Got {type(col)} instead of MicroSeries"
         assert hasattr(col, "weights")
         assert hasattr(col, "set_weights")
 
     def test_microdataframe_operations_preserve_type(self):
-        """
-        Operations on MicroDataFrame columns should preserve MicroSeries type.
-        """
+        """Operations on MicroDataFrame columns should preserve MicroSeries
+        type."""
         mdf = MicroDataFrame(
-            {"a": [1, 2, 3], "b": [4, 5, 6]},
-            weights=np.array([1.0, 2.0, 3.0])
+            {"a": [1, 2, 3], "b": [4, 5, 6]}, weights=np.array([1.0, 2.0, 3.0])
         )
 
         # Column operations
         result = mdf["a"] + mdf["b"]
-        assert isinstance(result, MicroSeries), f"Got {type(result)} instead of MicroSeries"
+        assert isinstance(
+            result, MicroSeries
+        ), f"Got {type(result)} instead of MicroSeries"
         assert hasattr(result, "weights")
 
 
@@ -121,21 +130,17 @@ class TestStringDtypeHandling:
     """Test that MicroSeries/MicroDataFrame handle pandas 3 string dtypes."""
 
     def test_microseries_with_string_data(self):
-        """
-        MicroSeries should work with string data in pandas 3.
-        """
+        """MicroSeries should work with string data in pandas 3."""
         # Create with string data
         ms = MicroSeries(["a", "b", "c"], weights=np.array([1.0, 2.0, 3.0]))
         assert len(ms) == 3
         assert hasattr(ms, "weights")
 
     def test_microdataframe_with_string_columns(self):
-        """
-        MicroDataFrame should work with string columns in pandas 3.
-        """
+        """MicroDataFrame should work with string columns in pandas 3."""
         mdf = MicroDataFrame(
             {"names": ["alice", "bob", "charlie"], "values": [1, 2, 3]},
-            weights=np.array([1.0, 2.0, 3.0])
+            weights=np.array([1.0, 2.0, 3.0]),
         )
         assert len(mdf) == 3
 
@@ -169,9 +174,7 @@ class TestCopyOnWriteCompatibility:
     """Test compatibility with pandas 3 Copy-on-Write."""
 
     def test_microseries_copy_independent(self):
-        """
-        Copying a MicroSeries should create an independent copy.
-        """
+        """Copying a MicroSeries should create an independent copy."""
         ms = MicroSeries([1, 2, 3], weights=np.array([1.0, 2.0, 3.0]))
         ms_copy = ms.copy()
 
@@ -182,12 +185,9 @@ class TestCopyOnWriteCompatibility:
         assert np.allclose(ms_copy.weights, [1.0, 2.0, 3.0])
 
     def test_microdataframe_copy_independent(self):
-        """
-        Copying a MicroDataFrame should create an independent copy.
-        """
+        """Copying a MicroDataFrame should create an independent copy."""
         mdf = MicroDataFrame(
-            {"a": [1, 2, 3]},
-            weights=np.array([1.0, 2.0, 3.0])
+            {"a": [1, 2, 3]}, weights=np.array([1.0, 2.0, 3.0])
         )
         mdf_copy = mdf.copy()
 
@@ -197,14 +197,32 @@ class TestCopyOnWriteCompatibility:
         # Copy should be unchanged
         assert np.allclose(mdf_copy.weights, [1.0, 2.0, 3.0])
 
+    def test_column_set_weights_after_access_regression(self):
+        """Regression test for pandas 3.0 CoW compatibility.
+
+        In pandas 3.0 with Copy-on-Write, modifying column.__class__ doesn't
+        persist because each access returns a copy. This test verifies the fix
+        that wraps columns as MicroSeries on access in __getitem__.
+        """
+        mdf = MicroDataFrame(
+            {"income": [10000, 20000, 30000]},
+            weights=np.array([1.0, 2.0, 3.0]),
+        )
+
+        # This was the exact error that occurred:
+        # AttributeError: 'Series' object has no attribute 'set_weights'
+        col = mdf["income"]
+        col.set_weights(np.array([4.0, 5.0, 6.0]))  # Would fail before fix
+
+        # Verify the new weights took effect
+        assert np.allclose(col.weights, [4.0, 5.0, 6.0])
+
 
 class TestGroupByWithPandas3:
     """Test groupby operations with pandas 3."""
 
     def test_microseries_groupby_preserves_weights(self):
-        """
-        GroupBy operations should preserve weights.
-        """
+        """GroupBy operations should preserve weights."""
         ms = MicroSeries([1, 2, 3, 4], weights=np.array([1.0, 2.0, 3.0, 4.0]))
         groups = pd.Series(["a", "a", "b", "b"])
 
@@ -217,12 +235,10 @@ class TestGroupByWithPandas3:
         assert result["b"] == 25
 
     def test_microdataframe_groupby_preserves_weights(self):
-        """
-        MicroDataFrame groupby should preserve weights on columns.
-        """
+        """MicroDataFrame groupby should preserve weights on columns."""
         mdf = MicroDataFrame(
             {"group": ["a", "a", "b", "b"], "value": [1, 2, 3, 4]},
-            weights=np.array([1.0, 2.0, 3.0, 4.0])
+            weights=np.array([1.0, 2.0, 3.0, 4.0]),
         )
 
         gb = mdf.groupby("group")

{microdf_python-1.2.0.dist-info → microdf_python-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.2.0
+Version: 1.2.2
 Summary: Weighted pandas DataFrames and Series for survey microdata
 Author-email: Max Ghenis <max@policyengine.org>
 License: MIT
@@ -20,6 +20,7 @@ Requires-Dist: linecheck; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: towncrier>=24.8.0; extra == "dev"
 Dynamic: license-file
 
 [![Build](https://github.com/PolicyEngine/microdf/workflows/Pull%20request/badge.svg)](https://github.com/PolicyEngine/microdf/actions)

microdf_python-1.2.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+microdf/__init__.py,sha256=ldRvhE8t4cD7qlxQ5yLndMnWEUYpDw4m-jCDV_psXkY,319
+microdf/microdataframe.py,sha256=2lZU3FAtVCgKiVD-iD_3xu3NMEEl-7Tbn-T-aOR_ihc,33920
+microdf/microseries.py,sha256=2-UmvJJkxycvqtIW6NfQr1HXFs-LTRctvQr6bkVNYdI,25061
+microdf/tests/conftest.py,sha256=u-EMyX1-u_nM-YO0RJYCzYHQDXxUI2WQE6GkyJlErqg,150
+microdf/tests/test_microseries_dataframe.py,sha256=YidEKYJwwPyCf_ZiAXoc8kydHj4XkZO-0jXQ-olouho,16284
+microdf/tests/test_pandas3_compatibility.py,sha256=p4SZoW59REA5GV84HH9InfCdKQ1nEBGmatnRK84GiGY,8623
+microdf_python-1.2.2.dist-info/licenses/LICENSE,sha256=uPs-ASYnzlldpf2z8jeRgQFeEH3FLhSuX0rw0OKWoDU,1067
+microdf_python-1.2.2.dist-info/METADATA,sha256=o-2nZ_NkEuvOF-BgVG-3oCRr_3X5YdXg15utoUPCfdM,2469
+microdf_python-1.2.2.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+microdf_python-1.2.2.dist-info/top_level.txt,sha256=T2WFPTygQQMdS3GF8YpZ12DKfMGrspbZ3r7z-e3KfiM,8
+microdf_python-1.2.2.dist-info/RECORD,,

{microdf_python-1.2.0.dist-info → microdf_python-1.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (82.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

microdf_python-1.2.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-microdf/__init__.py,sha256=ldRvhE8t4cD7qlxQ5yLndMnWEUYpDw4m-jCDV_psXkY,319
-microdf/microdataframe.py,sha256=h0vIuCACMo1BuV3VKDIEfhc_UwMUV5kUsnlQe3bHfgM,33539
-microdf/microseries.py,sha256=YRnSHVm3mGGd1_-D29BAUDaqWoIiwGjJPKYUrnWbinY,23376
-microdf/tests/conftest.py,sha256=u-EMyX1-u_nM-YO0RJYCzYHQDXxUI2WQE6GkyJlErqg,150
-microdf/tests/test_microseries_dataframe.py,sha256=lG2_3lJqTdGekbbJRFl0Vp0b4DEQwTk6scXr-ncOHgs,14647
-microdf/tests/test_pandas3_compatibility.py,sha256=H2pRtYoLkQD3MEv1Xh6J38b4POaUae9mGRwsLhf1rng,7807
-microdf_python-1.2.0.dist-info/licenses/LICENSE,sha256=uPs-ASYnzlldpf2z8jeRgQFeEH3FLhSuX0rw0OKWoDU,1067
-microdf_python-1.2.0.dist-info/METADATA,sha256=uBlNPTndvTGm0pI69qD9O1vIgFfckqc-S7Oe0wZDdbo,2420
-microdf_python-1.2.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-microdf_python-1.2.0.dist-info/top_level.txt,sha256=T2WFPTygQQMdS3GF8YpZ12DKfMGrspbZ3r7z-e3KfiM,8
-microdf_python-1.2.0.dist-info/RECORD,,