microdf-python 1.1.1__tar.gz → 1.2.0__tar.gz

{microdf_python-1.1.1/microdf_python.egg-info → microdf_python-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.1.1
+Version: 1.2.0
 Summary: Weighted pandas DataFrames and Series for survey microdata
 Author-email: Max Ghenis <max@policyengine.org>
 License: MIT

{microdf_python-1.1.1 → microdf_python-1.2.0}/microdf/microdataframe.py

@@ -44,6 +44,10 @@ class _MicroLocIndexer:
         self._parent_loc[key] = value
         self._mdf._link_all_weights()
 
+    def __getattr__(self, name):
+        """Delegate unknown attributes to the parent loc indexer."""
+        return getattr(self._parent_loc, name)
+
 
 class _MicroILocIndexer:
     """Custom iloc indexer that returns MicroDataFrame with proper weights."""
@@ -85,6 +89,10 @@ class _MicroILocIndexer:
         self._parent_iloc[key] = value
         self._mdf._link_all_weights()
 
+    def __getattr__(self, name):
+        """Delegate unknown attributes to the parent iloc indexer."""
+        return getattr(self._parent_iloc, name)
+
 
 class MicroDataFrame(pd.DataFrame):
     def __init__(self, *args, weights=None, **kwargs):

{microdf_python-1.1.1 → microdf_python-1.2.0}/microdf/microseries.py

@@ -101,13 +101,32 @@ class MicroSeries(pd.Series):
         return self.weights.sum()
 
     @scalar_function
-    def mean(self) -> float:
+    def mean(self, skipna: bool = True) -> float:
         """Calculates the weighted mean of the MicroSeries.
 
+        :param skipna: Exclude NA/null values. If True (default), NaN values
+            are excluded. If False, returns NaN if any value is NaN.
+        :type skipna: bool
         :returns: The weighted mean.
         :rtype: float
         """
-        return np.average(self.values, weights=self.weights)
+        values = self.values
+        weights = self.weights
+
+        if skipna:
+            # Create mask for non-NaN values
+            mask = ~pd.isna(values)
+            if not mask.any():
+                # All values are NaN
+                return np.nan
+            values = values[mask]
+            weights = weights[mask]
+
+        # If skipna=False and there are any NaN values, return NaN
+        if not skipna and pd.isna(values).any():
+            return np.nan
+
+        return np.average(values, weights=weights)
 
     def quantile(self, q: np.array) -> pd.Series:
         """Calculates weighted quantiles of the MicroSeries.

{microdf_python-1.1.1 → microdf_python-1.2.0}/microdf/tests/test_microseries_dataframe.py

@@ -94,6 +94,36 @@ def test_mean() -> None:
         pass
 
 
+def test_mean_skipna() -> None:
+    # Test skipna=True (default) - should skip NaN values
+    arr = np.array([3.0, np.nan, 2.0])
+    w = np.array([4.0, 1.0, 1.0])
+    series = mdf.MicroSeries(arr, weights=w)
+
+    # skipna=True should exclude NaN and its weight
+    expected = np.average([3.0, 2.0], weights=[4.0, 1.0])
+    assert series.mean(skipna=True) == expected
+    assert series.mean() == expected  # Default should be skipna=True
+
+    # Test skipna=False - should return NaN if any value is NaN
+    assert np.isnan(series.mean(skipna=False))
+
+    # Test with all NaN values
+    arr_all_nan = np.array([np.nan, np.nan, np.nan])
+    w_all_nan = np.array([1.0, 2.0, 3.0])
+    series_all_nan = mdf.MicroSeries(arr_all_nan, weights=w_all_nan)
+    assert np.isnan(series_all_nan.mean(skipna=True))
+    assert np.isnan(series_all_nan.mean(skipna=False))
+
+    # Test with no NaN values - skipna should not affect result
+    arr_no_nan = np.array([3.0, 5.0, 2.0])
+    w_no_nan = np.array([4.0, 1.0, 1.0])
+    series_no_nan = mdf.MicroSeries(arr_no_nan, weights=w_no_nan)
+    expected_no_nan = np.average(arr_no_nan, weights=w_no_nan)
+    assert series_no_nan.mean(skipna=True) == expected_no_nan
+    assert series_no_nan.mean(skipna=False) == expected_no_nan
+
+
 def test_poverty_count() -> None:
     arr = np.array([10000, 20000, 50000])
     w = np.array([1123, 1144, 2211])

microdf_python-1.2.0/microdf/tests/test_pandas3_compatibility.py

@@ -0,0 +1,232 @@
+"""
+Tests for pandas 3.0.0 compatibility in microdf.
+
+These tests verify that microdf works correctly with pandas 3.0.0,
+which introduces:
+1. PyArrow-backed strings as default (StringDtype)
+2. Copy-on-Write by default
+3. Changes to how Series subclasses are handled
+"""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from microdf.microseries import MicroSeries
+from microdf.microdataframe import MicroDataFrame
+
+
+class TestMicroSeriesSubclassPreservation:
+    """Test that MicroSeries subclass is preserved across operations."""
+
+    def test_microseries_set_weights_after_creation(self):
+        """
+        Ensure set_weights works on MicroSeries.
+        This is the error reported in pandas 3:
+        AttributeError: 'Series' object has no attribute 'set_weights'
+        """
+        ms = MicroSeries([1, 2, 3], weights=np.array([1.0, 1.0, 1.0]))
+        assert hasattr(ms, "set_weights")
+        assert hasattr(ms, "weights")
+
+        # Should be able to call set_weights
+        ms.set_weights(np.array([2.0, 2.0, 2.0]))
+        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.
+        """
+        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 hasattr(result, "weights")
+        assert hasattr(result, "set_weights")
+
+        # Multiplication
+        result = ms * 2
+        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"
+
+    def test_microseries_preserved_after_comparison(self):
+        """
+        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 hasattr(result, "weights")
+
+        # Less than
+        result = ms < 3
+        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]))
+
+        # Boolean indexing
+        result = ms[ms > 2]
+        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"
+
+
+class TestMicroDataFrameSubclassPreservation:
+    """Test that MicroDataFrame column access returns MicroSeries."""
+
+    def test_microdataframe_column_returns_microseries(self):
+        """
+        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])
+        )
+
+        # Column access
+        col = mdf["a"]
+        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.
+        """
+        mdf = MicroDataFrame(
+            {"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 hasattr(result, "weights")
+
+
+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.
+        """
+        # 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.
+        """
+        mdf = MicroDataFrame(
+            {"names": ["alice", "bob", "charlie"], "values": [1, 2, 3]},
+            weights=np.array([1.0, 2.0, 3.0])
+        )
+        assert len(mdf) == 3
+
+        # String column access should still work
+        names = mdf["names"]
+        assert len(names) == 3
+
+
+class TestWeightedOperationsWithPandas3:
+    """Test that weighted operations work correctly with pandas 3."""
+
+    def test_weighted_sum(self):
+        """Weighted sum should work correctly."""
+        ms = MicroSeries([1, 2, 3], weights=np.array([1.0, 2.0, 3.0]))
+        # Weighted sum: 1*1 + 2*2 + 3*3 = 1 + 4 + 9 = 14
+        assert ms.sum() == 14
+
+    def test_weighted_mean(self):
+        """Weighted mean should work correctly."""
+        ms = MicroSeries([1, 2, 3], weights=np.array([1.0, 2.0, 3.0]))
+        # Weighted mean: (1*1 + 2*2 + 3*3) / (1 + 2 + 3) = 14 / 6 ≈ 2.333
+        assert np.isclose(ms.mean(), 14 / 6)
+
+    def test_weighted_count(self):
+        """Weighted count should return sum of weights."""
+        ms = MicroSeries([1, 2, 3], weights=np.array([1.0, 2.0, 3.0]))
+        assert ms.count() == 6.0
+
+
+class TestCopyOnWriteCompatibility:
+    """Test compatibility with pandas 3 Copy-on-Write."""
+
+    def test_microseries_copy_independent(self):
+        """
+        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()
+
+        # Modify original
+        ms.set_weights(np.array([4.0, 5.0, 6.0]))
+
+        # Copy should be unchanged
+        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.
+        """
+        mdf = MicroDataFrame(
+            {"a": [1, 2, 3]},
+            weights=np.array([1.0, 2.0, 3.0])
+        )
+        mdf_copy = mdf.copy()
+
+        # Modify original
+        mdf.set_weights(np.array([4.0, 5.0, 6.0]))
+
+        # Copy should be unchanged
+        assert np.allclose(mdf_copy.weights, [1.0, 2.0, 3.0])
+
+
+class TestGroupByWithPandas3:
+    """Test groupby operations with pandas 3."""
+
+    def test_microseries_groupby_preserves_weights(self):
+        """
+        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"])
+
+        gb = ms.groupby(groups)
+        # Should be able to call weighted operations
+        result = gb.sum()
+        # Group a: 1*1 + 2*2 = 5
+        # Group b: 3*3 + 4*4 = 25
+        assert result["a"] == 5
+        assert result["b"] == 25
+
+    def test_microdataframe_groupby_preserves_weights(self):
+        """
+        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])
+        )
+
+        gb = mdf.groupby("group")
+        result = gb.sum()
+
+        # Check that weighted sum was computed
+        assert "value" in result.columns

{microdf_python-1.1.1 → microdf_python-1.2.0/microdf_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.1.1
+Version: 1.2.0
 Summary: Weighted pandas DataFrames and Series for survey microdata
 Author-email: Max Ghenis <max@policyengine.org>
 License: MIT

{microdf_python-1.1.1 → microdf_python-1.2.0}/microdf_python.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ microdf/microdataframe.py
 microdf/microseries.py
 microdf/tests/conftest.py
 microdf/tests/test_microseries_dataframe.py
+microdf/tests/test_pandas3_compatibility.py
 microdf_python.egg-info/PKG-INFO
 microdf_python.egg-info/SOURCES.txt
 microdf_python.egg-info/dependency_links.txt

{microdf_python-1.1.1 → microdf_python-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "microdf-python"
-version = "1.1.1"
+version = "1.2.0"
 description = "Weighted pandas DataFrames and Series for survey microdata"
 readme = "README.md"
 authors = [