microdf-python 1.5.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

microdf/microdataframe.py

@@ -460,7 +460,7 @@ class MicroDataFrame(WeightPropagationMixin, pd.DataFrame):
         if inplace:
             # Snapshot weight *values* positionally — the index is about
             # to change and reset_index preserves row order.
-            weight_values = np.asarray(self.weights.values, dtype=float)
+            weight_values = np.array(self.weights, dtype=float, copy=True)
             super().reset_index(
                 level=level,
                 drop=drop,
@@ -470,7 +470,7 @@ class MicroDataFrame(WeightPropagationMixin, pd.DataFrame):
                 allow_duplicates=allow_duplicates,
                 names=names,
             )
-            self.weights = pd.Series(weight_values, index=self.index, dtype=float)
+            self.weights = weight_series(weight_values, self.index)
             self._link_all_weights()
             return None
         else:
@@ -483,15 +483,9 @@ class MicroDataFrame(WeightPropagationMixin, pd.DataFrame):
                 allow_duplicates=allow_duplicates,
                 names=names,
             )
-            out = MicroDataFrame(res, weights=self.weights.values)
-            # Ensure weights align to res.index (reset_index changes the
-            # index but preserves row order, so pass values positionally).
-            out.weights = pd.Series(
-                np.asarray(self.weights.values, dtype=float),
-                index=out.index,
-                dtype=float,
-            )
-            return out
+            # Own a positional copy: reset_index changes labels but
+            # preserves row order.
+            return MicroDataFrame(res, weights=weight_series(self.weights, res.index))
 
     def copy(self, deep: Optional[bool] = True) -> "MicroDataFrame":
         return super().copy(deep)

microdf/microseries.py

@@ -120,6 +120,16 @@ class MicroSeries(WeightPropagationMixin, pd.Series):
         super().__finalize__(other, method=method, **kwargs)
         return finalize_weights(self, other, method, previous)
 
+    def _construct_result(self, *args, **kwargs):
+        # pandas has already aligned this Series before constructing a binary
+        # result. Retain its row weights, even when pandas 3 also finalizes
+        # metadata from the other operand. Delegate values and names to pandas.
+        result = super()._construct_result(*args, **kwargs)
+        if not isinstance(result, tuple):
+            result.weights = weight_series(self.weights, result.index)
+        # divmod constructs both tuple members through this same hook.
+        return result
+
     def __setattr__(self, name, value):
         weights = self.__dict__.get("weights") if name == "index" else None
         super().__setattr__(name, value)
@@ -935,95 +945,45 @@ class MicroSeries(WeightPropagationMixin, pd.Series):
     def __getattr__(self, name: str) -> "MicroSeries":
         return MicroSeries(super().__getattr__(name), weights=self.weights)
 
-    # operators
-
-    def __add__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__add__(other), weights=self.weights)
-
-    def __sub__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__sub__(other), weights=self.weights)
-
-    def __mul__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__mul__(other), weights=self.weights)
-
-    def __floordiv__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__floordiv__(other), weights=self.weights)
-
-    def __truediv__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__truediv__(other), weights=self.weights)
-
-    def __mod__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__mod__(other), weights=self.weights)
-
-    def __pow__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__pow__(other), weights=self.weights)
-
-    def __xor__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__xor__(other), weights=self.weights)
-
-    def __and__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__and__(other), weights=self.weights)
-
-    def __or__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__or__(other), weights=self.weights)
-
-    def __invert__(self) -> "MicroSeries":
-        return MicroSeries(super().__invert__(), weights=self.weights)
-
+    # Explicit reverse overrides give this subclass priority when a plain
+    # pandas Series is on the left. _construct_result retains aligned weights.
     def __radd__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__radd__(other), weights=self.weights)
+        return super().__radd__(other)
 
     def __rsub__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__rsub__(other), weights=self.weights)
+        return super().__rsub__(other)
 
     def __rmul__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__rmul__(other), weights=self.weights)
+        return super().__rmul__(other)
 
     def __rfloordiv__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__rfloordiv__(other), weights=self.weights)
+        return super().__rfloordiv__(other)
 
     def __rtruediv__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__rtruediv__(other), weights=self.weights)
+        return super().__rtruediv__(other)
 
     def __rmod__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__rmod__(other), weights=self.weights)
+        return super().__rmod__(other)
 
     def __rpow__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__rpow__(other), weights=self.weights)
+        return super().__rpow__(other)
 
     def __rand__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__rand__(other), weights=self.weights)
+        return super().__rand__(other)
 
     def __ror__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__ror__(other), weights=self.weights)
+        return super().__ror__(other)
 
     def __rxor__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__rxor__(other), weights=self.weights)
+        return super().__rxor__(other)
+
+    def __invert__(self) -> "MicroSeries":
+        return MicroSeries(super().__invert__(), weights=self.weights)
 
     def sqrt(self) -> "MicroSeries":
         sqrt_values = np.sqrt(self._values)
         return MicroSeries(sqrt_values, index=self.index, weights=self.weights)
 
-    # comparators
-
-    def __lt__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__lt__(other), weights=self.weights)
-
-    def __le__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__le__(other), weights=self.weights)
-
-    def __eq__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__eq__(other), weights=self.weights)
-
-    def __ne__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__ne__(other), weights=self.weights)
-
-    def __ge__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__ge__(other), weights=self.weights)
-
-    def __gt__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
-        return MicroSeries(super().__gt__(other), weights=self.weights)
-
     # assignment operators
 
     def __iadd__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":

microdf/tests/test_binary_weight_alignment.py

@@ -0,0 +1,195 @@
+"""Binary operations retain the calling Series' observation weights."""
+
+import inspect
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from microdf import MicroSeries
+
+
+ARITHMETIC = ["add", "sub", "mul", "truediv", "floordiv", "mod", "pow"]
+LOGICAL = ["and", "or", "xor"]
+COMPARISONS = ["lt", "le", "eq", "ne", "ge", "gt"]
+
+
+def assert_weighted_result(result, expected, source):
+    assert isinstance(result, MicroSeries)
+    pd.testing.assert_series_equal(pd.Series(result), expected)
+    expected_weights = (
+        source.weights
+        if source.index.equals(expected.index)
+        else source.weights.reindex(expected.index)
+    )
+    pd.testing.assert_series_equal(result.weights, expected_weights)
+    assert result.weights is not source.weights
+    assert result.sum() == expected.multiply(expected_weights).sum()
+
+
+@pytest.mark.parametrize(
+    "method",
+    [f"__{prefix}{op}__" for op in ARITHMETIC + LOGICAL for prefix in ["", "r"]],
+)
+@pytest.mark.parametrize("weighted_other", [False, True])
+def test_binary_operators_align_weights_with_labels(method, weighted_other):
+    source = MicroSeries([10, 20], index=["b", "a"], weights=[1, 9], name="x")
+    other = pd.Series([2, 1], index=["a", "b"], name="x")
+    if weighted_other:
+        other = MicroSeries(other, weights=[9, 1])
+    expected = getattr(pd.Series(source), method)(pd.Series(other))
+
+    result = getattr(source, method)(other)
+
+    assert_weighted_result(result, expected, source)
+    # Addition is 22 * 9 + 11 * 1 = 209, rather than the positional 121.
+    if method in ["__add__", "__radd__"]:
+        assert result.sum() == 209
+    result.weights.iloc[0] = 100
+    np.testing.assert_array_equal(source.weights, [1, 9])
+    if weighted_other:
+        np.testing.assert_array_equal(other.weights, [9, 1])
+    source.weights.iloc[1] = 200
+    assert result.weights.iloc[0] == 100
+
+
+@pytest.mark.parametrize(
+    "method",
+    ARITHMETIC + [f"r{op}" for op in ARITHMETIC] + COMPARISONS + ["div", "rdiv"],
+)
+@pytest.mark.parametrize("permuted", [False, True])
+def test_named_binary_methods_use_calling_series_weights(method, permuted):
+    source = MicroSeries([10, 20], index=["b", "a"], weights=[1, 9], name="x")
+    other = MicroSeries(
+        [2, 1], index=["a", "b"] if permuted else ["b", "a"], weights=[5, 7], name="x"
+    )
+    expected = getattr(pd.Series(source), method)(pd.Series(other))
+
+    result = getattr(source, method)(other)
+
+    assert_weighted_result(result, expected, source)
+    # Inherited public methods keep the installed pandas API signatures.
+    assert inspect.signature(getattr(MicroSeries, method)) == inspect.signature(
+        getattr(pd.Series, method)
+    )
+
+
+@pytest.mark.parametrize("method", [f"__{op}__" for op in COMPARISONS])
+def test_comparison_operators_keep_calling_series_weights_and_pandas_errors(method):
+    source = MicroSeries([10, 20], index=["b", "a"], weights=[1, 9])
+    other = MicroSeries([20, 10], index=source.index, weights=[5, 7])
+    expected = getattr(pd.Series(source), method)(pd.Series(other))
+    assert_weighted_result(getattr(source, method)(other), expected, source)
+
+    other.index = ["a", "b"]
+    with pytest.raises(ValueError) as pandas_error:
+        getattr(pd.Series(source), method)(pd.Series(other))
+    with pytest.raises(ValueError) as microdf_error:
+        getattr(source, method)(other)
+    assert str(microdf_error.value) == str(pandas_error.value)
+
+
+@pytest.mark.parametrize("method", ["__add__", "__rsub__", "add", "rsub", "lt"])
+@pytest.mark.parametrize("operand", [3, [2, 1], np.array([2, 1])])
+def test_scalar_and_array_binary_operands_keep_weights(method, operand):
+    source = MicroSeries([10, 20], index=["b", "a"], weights=[1, 9])
+    expected = getattr(pd.Series(source), method)(operand)
+    assert_weighted_result(getattr(source, method)(operand), expected, source)
+
+
+@pytest.mark.parametrize("method", ["__add__", "__rsub__", "add", "rsub", "lt"])
+def test_matching_duplicate_indexes_keep_positional_weights(method):
+    source = MicroSeries([10, 20, 30], index=["a", "a", "b"], weights=[1, 9, 3])
+    other = MicroSeries([2, 1, 4], index=source.index, weights=[5, 7, 11])
+    expected = getattr(pd.Series(source), method)(pd.Series(other))
+    assert_weighted_result(getattr(source, method)(other), expected, source)
+
+
+@pytest.mark.parametrize("method", ["__divmod__", "__rdivmod__", "divmod", "rdivmod"])
+def test_divmod_results_keep_calling_series_weights(method):
+    source = MicroSeries([10, 20], index=["b", "a"], weights=[1, 9])
+    other = MicroSeries([3, 4], index=["a", "b"], weights=[5, 7])
+    expected = getattr(pd.Series(source), method)(pd.Series(other))
+    result = getattr(source, method)(other)
+    assert isinstance(result, tuple)
+    for actual, plain in zip(result, expected):
+        assert_weighted_result(actual, plain, source)
+
+
+@pytest.mark.parametrize("method", ["__add__", "__rsub__", "add", "rsub", "lt"])
+@pytest.mark.parametrize(
+    "left_index,right_index",
+    [
+        (["b", "a"], ["a", "c"]),
+        (["b", "a", "b"], ["a", "b", "b"]),
+    ],
+    ids=["new-rows", "ambiguous-duplicates"],
+)
+def test_binary_operations_reject_unknown_row_weights(method, left_index, right_index):
+    source = MicroSeries(
+        range(len(left_index)), index=left_index, weights=range(1, len(left_index) + 1)
+    )
+    other = MicroSeries(
+        range(len(right_index)),
+        index=right_index,
+        weights=range(4, len(right_index) + 4),
+    )
+    with pytest.raises(ValueError, match="weights"):
+        getattr(source, method)(other)
+
+
+@pytest.mark.parametrize("method", ["add", "rsub", "lt"])
+def test_named_binary_arguments_preserve_pandas_values_and_errors(method):
+    index = pd.MultiIndex.from_tuples([("b", 2), ("a", 1)], names=["group", "row"])
+    source = MicroSeries([np.nan, 20], index=index, weights=[1, 9])
+    other = pd.Series([2, 1], index=pd.Index(["a", "b"], name="group"))
+    kwargs = {"level": "group", "fill_value": 0, "axis": "index"}
+    expected = getattr(pd.Series(source), method)(other, **kwargs)
+    assert_weighted_result(getattr(source, method)(other, **kwargs), expected, source)
+    for args, options in [
+        ((other,), {"axis": 1}),
+        (([1],), {}),
+        ((other,), {"unknown": True}),
+    ]:
+        with pytest.raises((TypeError, ValueError)) as pandas_error:
+            getattr(pd.Series(source), method)(*args, **options)
+        with pytest.raises(type(pandas_error.value)) as microdf_error:
+            getattr(source, method)(*args, **options)
+        # pandas identifies the concrete subclass in invalid-axis messages.
+        expected_error = str(pandas_error.value).replace(
+            "object type Series", "object type MicroSeries"
+        )
+        assert str(microdf_error.value) == expected_error
+
+
+@pytest.mark.parametrize(
+    "operation",
+    [
+        lambda plain, weighted: plain + weighted,
+        lambda plain, weighted: plain - weighted,
+        lambda plain, weighted: plain * weighted,
+        lambda plain, weighted: plain / weighted,
+        lambda plain, weighted: plain // weighted,
+        lambda plain, weighted: plain % weighted,
+        lambda plain, weighted: plain**weighted,
+        lambda plain, weighted: plain & weighted,
+        lambda plain, weighted: plain | weighted,
+        lambda plain, weighted: plain ^ weighted,
+    ],
+    ids=ARITHMETIC + LOGICAL,
+)
+@pytest.mark.parametrize("indexes", ["matching", "permuted", "duplicates"])
+def test_plain_series_left_expressions_preserve_weighted_dispatch(operation, indexes):
+    index = ["a", "a"] if indexes == "duplicates" else ["b", "a"]
+    source = MicroSeries([10, 20], index=index, weights=[1, 9], name="x")
+    other_index = ["a", "b"] if indexes == "permuted" else index
+    other = pd.Series([2, 1], index=other_index, name="x")
+    expected = operation(other, pd.Series(source))
+
+    result = operation(other, source)
+
+    assert_weighted_result(result, expected, source)
+    result.weights.iloc[0] = 100
+    np.testing.assert_array_equal(source.weights, [1, 9])
+    source.weights.iloc[1] = 200
+    assert result.weights.iloc[0] == 100

microdf/tests/test_dataframe_weight_storage.py

@@ -59,3 +59,50 @@ def test_stored_weight_edits_do_not_change_weight_column(dtype):
 
     np.testing.assert_array_equal(df["w"], [1, 2])
     assert df.sum()["x"] == 10 * 100 + 20 * 2
+
+
+@pytest.mark.parametrize("drop", [False, True])
+@pytest.mark.parametrize("inplace", [False, True])
+@pytest.mark.parametrize(
+    "index,level",
+    [
+        (pd.Index(["b", "a", "a"], name="row"), None),
+        (
+            pd.MultiIndex.from_tuples(
+                [("b", 2), ("a", 1), ("a", 1)], names=["group", "row"]
+            ),
+            None,
+        ),
+        (
+            pd.MultiIndex.from_tuples(
+                [("b", 2), ("a", 1), ("a", 1)], names=["group", "row"]
+            ),
+            "group",
+        ),
+    ],
+)
+def test_reset_index_owns_independently_mutable_weights(index, level, drop, inplace):
+    source = mdf.MicroDataFrame({"x": [10, 20, 30]}, index=index, weights=[1, 9, 3])
+    original_weights = source.weights
+    expected = pd.DataFrame(source).reset_index(level=level, drop=drop)
+
+    result = source.reset_index(level=level, drop=drop, inplace=inplace)
+
+    if inplace:
+        assert result is None
+        result = source
+    assert isinstance(result, mdf.MicroDataFrame)
+    pd.testing.assert_frame_equal(pd.DataFrame(result), expected)
+    pd.testing.assert_series_equal(
+        result.weights, pd.Series([1.0, 9.0, 3.0], index=expected.index)
+    )
+    assert result.x.sum() == 10 * 1 + 20 * 9 + 30 * 3
+    assert result.weights is not original_weights
+    result.weights.iloc[0] = 100
+    np.testing.assert_array_equal(original_weights, [1, 9, 3])
+    assert result.x.sum() == 10 * 100 + 20 * 9 + 30 * 3
+    if not inplace:
+        assert source.x.sum() == 10 * 1 + 20 * 9 + 30 * 3
+    original_weights.iloc[1] = 200
+    np.testing.assert_array_equal(result.weights, [100, 9, 3])
+    assert result.x.sum() == 10 * 100 + 20 * 9 + 30 * 3

{microdf_python-1.5.0.dist-info → microdf_python-1.5.1.dist-info}/METADATA

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

{microdf_python-1.5.0.dist-info → microdf_python-1.5.1.dist-info}/RECORD

@@ -1,11 +1,12 @@
 microdf/__init__.py,sha256=G4m4UDiGePngG1i0DdGYhsTAXqyDELR6Mbq72OXOMG0,790
 microdf/_weights.py,sha256=uBOcTZGmVJlzi27sSAALSTb4V9j56tXuaBfJB83x7j0,10303
-microdf/microdataframe.py,sha256=yJNtsm-LNyB9_nyDUpV58nUQ3iZWWT0cZsD9Eu1j22w,39711
-microdf/microseries.py,sha256=G56sslazw5sY1t5i8FhqtPPEU12_vQNMlmsMKw6mdkU,47633
+microdf/microdataframe.py,sha256=BY5Knw4WP0TcdYM6qcSpPD1oUI9y087kxHkeyuarJoE,39475
+microdf/microseries.py,sha256=0btULkhRKvMMUEtvyGaFT2aycNT_lhU1MsPXP48wlpE,45531
 microdf/replication.py,sha256=3iZ6xG24ucKofVwmXxyd7ME6rZP6iJVnN9JpWcPxg9s,7697
 microdf/tests/conftest.py,sha256=u-EMyX1-u_nM-YO0RJYCzYHQDXxUI2WQE6GkyJlErqg,150
 microdf/tests/test_aggregation_errors.py,sha256=9jJDiEyxMb2z1Zmj-o8AHDNp8LOputbEkAMefifnWaE,2013
-microdf/tests/test_dataframe_weight_storage.py,sha256=ngIsWa_QcBnnaLpAyIZhTgMxjv_7cK8Nbf7f4n29R4Q,1975
+microdf/tests/test_binary_weight_alignment.py,sha256=d3-e7Kb6G8J22aVFTi3sOGUyDODKT1p0-XsEvMZBDvo,8115
+microdf/tests/test_dataframe_weight_storage.py,sha256=m77cbDn521ehIJWbgirjhL5Q5byBdm-UZhFkGx7mp6A,3667
 microdf/tests/test_microseries_dataframe.py,sha256=vL0fg_NydU6a5myVVtXyHMr8eQOB_yyAkZYwLmoEnOA,30075
 microdf/tests/test_nullify_weights_index.py,sha256=kZgzMaZEa_PXbsor2S4E-6VRid3C3rcC9ufk0qa7mgY,341
 microdf/tests/test_pandas3_compatibility.py,sha256=A34Ni_WQ303sSNv-sqv5CGAQp54zj-ZSGAPEBHZslNI,8573
@@ -16,8 +17,8 @@ microdf/tests/test_sum_axes.py,sha256=N05ocwI5lLv2OgoaovRIqFIae-70356kZemRRet0ac
 microdf/tests/test_version_metadata.py,sha256=M1EabzHLKZZw3Djd6Zu2UuMQtDLV6rZ1zDrOU7W_jf0,227
 microdf/tests/test_weight_propagation.py,sha256=3odbufFZ2o1rnyjx6PJ7kn1TPO5K2ho3RErczI7mqO4,18761
 microdf/tests/test_weighted_cov_corr.py,sha256=LTnFhMWnb28f7L_9kOhPiV5UlLMAUbC9OlLIaZ1XgLs,13954
-microdf_python-1.5.0.dist-info/licenses/LICENSE,sha256=uPs-ASYnzlldpf2z8jeRgQFeEH3FLhSuX0rw0OKWoDU,1067
-microdf_python-1.5.0.dist-info/METADATA,sha256=PTg6QSQEgnWdWkUaOsnpi2aQ64yMuSmrJ8nONUC3XcI,2305
-microdf_python-1.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-microdf_python-1.5.0.dist-info/top_level.txt,sha256=T2WFPTygQQMdS3GF8YpZ12DKfMGrspbZ3r7z-e3KfiM,8
-microdf_python-1.5.0.dist-info/RECORD,,
+microdf_python-1.5.1.dist-info/licenses/LICENSE,sha256=uPs-ASYnzlldpf2z8jeRgQFeEH3FLhSuX0rw0OKWoDU,1067
+microdf_python-1.5.1.dist-info/METADATA,sha256=iWnLVAQ4Ur-JthLTPsNnC3lC1xPrbz0vIKmI4oboEyo,2305
+microdf_python-1.5.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+microdf_python-1.5.1.dist-info/top_level.txt,sha256=T2WFPTygQQMdS3GF8YpZ12DKfMGrspbZ3r7z-e3KfiM,8
+microdf_python-1.5.1.dist-info/RECORD,,