microdf-python 1.5.0__tar.gz → 1.5.2__tar.gz

{microdf_python-1.5.0/microdf_python.egg-info → microdf_python-1.5.2}/PKG-INFO

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

{microdf_python-1.5.0 → microdf_python-1.5.2}/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_python-1.5.0 → microdf_python-1.5.2}/microdf/microseries.py

@@ -6,7 +6,12 @@ from typing import Callable, List, Optional, Union
 import numpy as np
 import pandas as pd
 
-from microdf._weights import WeightPropagationMixin, finalize_weights, weight_series
+from microdf._weights import (
+    WeightPropagationMixin,
+    aligned_weights,
+    finalize_weights,
+    weight_series,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -94,6 +99,10 @@ class MicroSeries(WeightPropagationMixin, pd.Series):
     # Keep pandas' own metadata, including the Series name.
     _metadata = pd.Series._metadata + ["weights"]
 
+    # These operands previously shared pandas' ufunc handler with MicroSeries.
+    # Keep inherited fallback paths working after overriding that handler.
+    _HANDLED_TYPES = pd.Series._HANDLED_TYPES + (pd.Series, pd.DataFrame)
+
     def __init__(self, *args, weights: np.array = None, **kwargs):
         """A Series-inheriting class for weighted microdata.
 
@@ -115,11 +124,90 @@ class MicroSeries(WeightPropagationMixin, pd.Series):
 
         return MicroDataFrame
 
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        # Preserve deferral to foreign handlers. A higher-priority Series
+        # inheriting pandas' handler cannot take over: pandas would defer back
+        # to our distinct handler, so handle that case through plain Series.
+        known_handlers = (
+            pd.Series.__array_ufunc__,
+            MicroSeries.__array_ufunc__,
+            type(self).__array_ufunc__,
+        )
+        inherited_series_priority = False
+        dispatch_index = 0
+        for position, value in enumerate(inputs):
+            if value is not self and isinstance(value, (pd.Series, pd.DataFrame)):
+                handler = type(value).__array_ufunc__
+                if handler not in known_handlers:
+                    return NotImplemented
+                if value.__array_priority__ > self.__array_priority__:
+                    if (
+                        isinstance(value, pd.Series)
+                        and handler is pd.Series.__array_ufunc__
+                    ):
+                        inherited_series_priority = True
+                        dispatch_index = position
+                    else:
+                        return NotImplemented
+
+        out = kwargs.get("out")
+        has_output = out is not None and any(value is not None for value in out)
+        if (
+            method == "__call__"
+            and len(inputs) == 2
+            and all(isinstance(value, pd.Series) for value in inputs)
+            and (not has_output or inherited_series_priority)
+        ):
+            # pandas' generic ufunc reconstruction drops metadata for multiple
+            # Series. Preserve pandas' selected handler receiver because it
+            # determines alignment order, including positional output masks.
+            plain = tuple(
+                pd.Series(value, copy=False).__finalize__(value) for value in inputs
+            )
+            if has_output:
+                # Match pandas' receiver-based alignment before it writes out.
+                # Reconstruction must not discover invalid row weights later.
+                result_index = plain[dispatch_index].index.union(plain[1].index)
+                aligned_weights(self, result_index)
+                for output in out:
+                    if isinstance(output, MicroSeries):
+                        aligned_weights(output, result_index)
+            result = pd.Series.__array_ufunc__(
+                plain[dispatch_index], ufunc, method, *plain, **kwargs
+            )
+
+            def restore_weights(value):
+                if isinstance(value, pd.Series):
+                    return self._weighted_result(
+                        value, aligned_weights(self, value.index)
+                    ).__finalize__(value)
+                return value
+
+            if isinstance(result, tuple):
+                return tuple(restore_weights(value) for value in result)
+            return restore_weights(result)
+        return super().__array_ufunc__(ufunc, method, *inputs, **kwargs)
+
+    def __rdivmod__(self, other) -> tuple["MicroSeries", "MicroSeries"]:
+        # An explicit override gives the weighted subclass priority over a
+        # plain Series on the left, as for the other reverse operators.
+        return super().__rdivmod__(other)
+
     def __finalize__(self, other, method=None, **kwargs):
         previous = self.__dict__.get("weights")
         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 +1023,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_python-1.5.2/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_python-1.5.0 → microdf_python-1.5.2}/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.2/microdf/tests/test_ufunc_weight_dispatch.py

@@ -0,0 +1,640 @@
+"""Binary NumPy dispatch retains the weights of identifiable observations."""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from microdf import MicroSeries
+
+
+def test_maximum_preserves_issue_322_weighted_total():
+    weighted = MicroSeries([10, 20], weights=[2, 9])
+
+    result = np.maximum(weighted, pd.Series([12, 10]))
+
+    assert isinstance(result, MicroSeries)
+    pd.testing.assert_series_equal(pd.Series(result), pd.Series([12, 20]))
+    pd.testing.assert_series_equal(result.weights, pd.Series([2.0, 9.0]))
+    assert result.sum() == 204  # 12 * 2 + 20 * 9.
+
+
+def test_plain_series_left_divmod_preserves_issue_322_weighted_totals():
+    weighted = MicroSeries([10, 20], weights=[2, 9])
+
+    quotient, remainder = divmod(pd.Series([23, 41]), weighted)
+
+    for result, values, total in [
+        (quotient, [2, 2], 22),  # 2 * 2 + 2 * 9.
+        (remainder, [3, 1], 15),  # 3 * 2 + 1 * 9.
+    ]:
+        assert isinstance(result, MicroSeries)
+        pd.testing.assert_series_equal(pd.Series(result), pd.Series(values))
+        pd.testing.assert_series_equal(result.weights, pd.Series([2.0, 9.0]))
+        assert result.sum() == total
+
+
+@pytest.mark.parametrize("ufunc", [np.maximum, np.minimum, np.fmax])
+@pytest.mark.parametrize("weighted_first", [True, False])
+@pytest.mark.parametrize(
+    "source_labels,other_labels,other_values,other_name,expected_weights",
+    [
+        (["b", "a", "c"], ["b", "a", "c"], [12, 10, 30], "income", [2, 9, 5]),
+        (["b", "a", "c"], ["c", "a", "b"], [30, 10, 12], "other", [9, 2, 5]),
+        (["a", "a", "b"], ["a", "a", "b"], [12, 10, 30], "income", [2, 9, 5]),
+    ],
+    ids=["matching", "reordered", "equal-duplicates"],
+)
+def test_binary_ufunc_preserves_values_row_weights_and_independence(
+    ufunc,
+    weighted_first,
+    source_labels,
+    other_labels,
+    other_values,
+    other_name,
+    expected_weights,
+):
+    source = pd.Series(
+        [10.0, 20.0, np.nan],
+        index=pd.Index(source_labels, name="person"),
+        name="income",
+    )
+    other = pd.Series(
+        other_values,
+        index=pd.Index(other_labels, name="person"),
+        name=other_name,
+    )
+    weighted = MicroSeries(source, weights=[2, 9, 5])
+    if weighted_first:
+        expected = ufunc(source, other)
+        result = ufunc(weighted, other)
+    else:
+        expected = ufunc(other, source)
+        result = ufunc(other, weighted)
+    weights = pd.Series(expected_weights, index=expected.index, dtype=float)
+
+    assert isinstance(result, MicroSeries)
+    pd.testing.assert_series_equal(pd.Series(result), expected)
+    pd.testing.assert_series_equal(result.weights, weights)
+    assert result.sum() == expected.multiply(weights).sum()
+
+    result.weights.iloc[0] = 100
+    pd.testing.assert_series_equal(
+        weighted.weights, pd.Series([2.0, 9.0, 5.0], index=source.index)
+    )
+    weighted.weights.iloc[-1] = 200
+    assert result.weights.iloc[-1] == expected_weights[-1]
+
+
+@pytest.mark.parametrize("operation", [divmod, np.divmod])
+@pytest.mark.parametrize(
+    "source_labels,other_labels,other_values,other_name,expected_weights",
+    [
+        (["b", "a", "c"], ["b", "a", "c"], [23, 41, 95], "income", [2, 9, 5]),
+        (["b", "a", "c"], ["c", "a", "b"], [95, 41, 23], "other", [9, 2, 5]),
+        (["a", "a", "b"], ["a", "a", "b"], [23, 41, 95], "income", [2, 9, 5]),
+    ],
+    ids=["matching", "reordered", "equal-duplicates"],
+)
+def test_reverse_divmod_retains_each_members_values_and_independent_weights(
+    operation,
+    source_labels,
+    other_labels,
+    other_values,
+    other_name,
+    expected_weights,
+):
+    source = pd.Series(
+        [10, 20, 30],
+        index=pd.Index(source_labels, name="person"),
+        name="income",
+    )
+    other = pd.Series(
+        other_values,
+        index=pd.Index(other_labels, name="person"),
+        name=other_name,
+    )
+    weighted = MicroSeries(source, weights=[2, 9, 5])
+    expected = operation(other, source)
+
+    result = operation(other, weighted)
+
+    assert isinstance(result, tuple)
+    assert len(result) == 2
+    for member, plain in zip(result, expected):
+        weights = pd.Series(expected_weights, index=plain.index, dtype=float)
+        assert isinstance(member, MicroSeries)
+        pd.testing.assert_series_equal(pd.Series(member), plain)
+        pd.testing.assert_series_equal(member.weights, weights)
+        assert member.sum() == plain.multiply(weights).sum()
+
+    quotient, remainder = result
+    quotient.weights.iloc[0] = 100
+    assert remainder.weights.iloc[0] == expected_weights[0]
+    remainder.weights.iloc[1] = 300
+    assert quotient.weights.iloc[1] == expected_weights[1]
+    pd.testing.assert_series_equal(
+        weighted.weights, pd.Series([2.0, 9.0, 5.0], index=source.index)
+    )
+    weighted.weights.iloc[-1] = 200
+    assert quotient.weights.iloc[-1] == expected_weights[-1]
+    assert remainder.weights.iloc[-1] == expected_weights[-1]
+
+
+@pytest.mark.parametrize(
+    "operation,source_labels,other_labels",
+    [
+        (np.maximum, ["a", "b", "c"], ["a", "b", "unknown"]),
+        (divmod, ["a", "b", "c"], ["a", "b", "unknown"]),
+        (np.divmod, ["a", "b", "c"], ["a", "b", "unknown"]),
+        (divmod, ["b", "a", "a"], ["a", "a", "b"]),
+        (np.divmod, ["b", "a", "a"], ["a", "a", "b"]),
+    ],
+    ids=[
+        "maximum-unknown-row",
+        "divmod-unknown-row",
+        "numpy-divmod-unknown-row",
+        "divmod-ambiguous-duplicate-rows",
+        "numpy-divmod-ambiguous-duplicate-rows",
+    ],
+)
+def test_binary_dispatch_rejects_rows_without_unambiguous_weights(
+    operation, source_labels, other_labels
+):
+    source = pd.Series([10, 20, 30], index=source_labels)
+    other = pd.Series([23, 41, 95], index=other_labels)
+    weighted = MicroSeries(source, weights=[2, 9, 5])
+    # Pandas can produce values, but these rows have no unique weight assignment.
+    operation(other, source)
+
+    with pytest.raises(ValueError, match="weights"):
+        operation(other, weighted)
+
+
+@pytest.mark.parametrize("ufunc", [np.maximum, np.minimum, np.fmax])
+def test_binary_ufunc_preserves_pandas_duplicate_alignment_errors(ufunc):
+    source = pd.Series([10, 20, 30], index=["b", "a", "a"])
+    other = pd.Series([23, 41, 95], index=["a", "a", "b"])
+    weighted = MicroSeries(source, weights=[2, 9, 5])
+
+    with pytest.raises(ValueError) as pandas_error:
+        ufunc(other, source)
+    with pytest.raises(type(pandas_error.value)) as microdf_error:
+        ufunc(other, weighted)
+
+    assert str(microdf_error.value) == str(pandas_error.value)
+
+
+@pytest.mark.parametrize("operation", [np.maximum, divmod, np.divmod])
+def test_binary_dispatch_preserves_pandas_invalid_dtype_errors(operation):
+    source = pd.Series([10, 20], index=["a", "b"], name="income")
+    other = pd.Series(["invalid", "data"], index=source.index, dtype=object)
+    weighted = MicroSeries(source, weights=[2, 9])
+
+    with pytest.raises(TypeError) as pandas_error:
+        operation(other, source)
+    with pytest.raises(type(pandas_error.value)) as microdf_error:
+        operation(other, weighted)
+
+    assert str(microdf_error.value) == str(pandas_error.value)
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+def test_binary_ufunc_preserves_pandas_ndarray_out_and_where(weighted_first):
+    source = pd.Series([10.0, 20.0, 30.0], index=["b", "a", "c"], name="income")
+    other = pd.Series([12.0, 10.0, 40.0], index=source.index, name="income")
+    weighted = MicroSeries(source, weights=[2, 9, 5])
+    out = np.full(3, -99.0)
+    plain_out = out.copy()
+    plain_inputs = (source, other) if weighted_first else (other, source)
+    inputs = (weighted, other) if weighted_first else (other, weighted)
+    where = np.array([True, False, True])
+    expected = np.maximum(*plain_inputs, out=plain_out, where=where)
+
+    result = np.maximum(*inputs, out=out, where=where)
+
+    assert (result is out) == (expected is plain_out)
+    np.testing.assert_array_equal(out, [12.0, -99.0, 40.0])
+    np.testing.assert_array_equal(out, plain_out)
+    pd.testing.assert_series_equal(pd.Series(result), expected)
+    assert np.shares_memory(np.asarray(result), out) == np.shares_memory(
+        np.asarray(expected), plain_out
+    )
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+def test_binary_ufunc_explicit_none_out_retains_weights(weighted_first):
+    source = pd.Series([10, 20], index=["b", "a"], name="income")
+    other = pd.Series([12, 10], index=source.index, name="income")
+    weighted = MicroSeries(source, weights=[2, 9])
+    plain_inputs = (source, other) if weighted_first else (other, source)
+    inputs = (weighted, other) if weighted_first else (other, weighted)
+    expected = np.maximum(*plain_inputs, out=None)
+
+    result = np.maximum(*inputs, out=None)
+
+    assert isinstance(result, MicroSeries)
+    pd.testing.assert_series_equal(pd.Series(result), expected)
+    pd.testing.assert_series_equal(
+        result.weights, pd.Series([2.0, 9.0], index=source.index)
+    )
+    assert result.sum() == 204  # 12 * 2 + 20 * 9.
+
+
+@pytest.mark.parametrize("ufunc", [np.negative, np.modf])
+def test_unary_ufunc_and_tuple_outputs_keep_existing_weight_behavior(ufunc):
+    source = pd.Series([10.25, -20.5], index=["b", "a"], name="income")
+    weighted = MicroSeries(source, weights=[2, 9])
+    expected = ufunc(source)
+
+    result = ufunc(weighted)
+
+    if isinstance(expected, tuple):
+        assert isinstance(result, tuple)
+        assert len(result) == len(expected)
+    else:
+        result, expected = (result,), (expected,)
+    weights = pd.Series([2.0, 9.0], index=source.index)
+    for member, plain in zip(result, expected):
+        assert isinstance(member, MicroSeries)
+        pd.testing.assert_series_equal(pd.Series(member), plain)
+        pd.testing.assert_series_equal(member.weights, weights)
+        assert member.sum() == plain.multiply(weights).sum()
+
+
+def test_add_ufunc_reduction_keeps_weighted_sum_behavior():
+    weighted = MicroSeries([10, 20], index=["b", "a"], weights=[2, 9])
+
+    assert np.add.reduce(weighted) == 200  # 10 * 2 + 20 * 9.
+
+
+@pytest.mark.parametrize("base", [pd.Series, pd.DataFrame])
+@pytest.mark.parametrize("weighted_first", [True, False])
+@pytest.mark.parametrize("higher_priority", [False, True])
+def test_binary_ufunc_defers_to_foreign_pandas_handlers(
+    base, weighted_first, higher_priority
+):
+    sentinel = object()
+    calls = []
+
+    class ForeignPandasObject(base):
+        __array_priority__ = MicroSeries.__array_priority__ + higher_priority
+
+        def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+            calls.append((ufunc, method, inputs, kwargs))
+            return sentinel
+
+    weighted = MicroSeries([10, 20], weights=[2, 9])
+    foreign = ForeignPandasObject([12, 10])
+    inputs = (weighted, foreign) if weighted_first else (foreign, weighted)
+
+    result = np.maximum(*inputs)
+
+    assert result is sentinel
+    assert len(calls) == 1
+    ufunc, method, received_inputs, kwargs = calls[0]
+    assert ufunc is np.maximum
+    assert method == "__call__"
+    assert len(received_inputs) == len(inputs)
+    assert all(
+        received is original for received, original in zip(received_inputs, inputs)
+    )
+    assert kwargs == {}
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+def test_binary_ufunc_defers_to_higher_priority_dataframe_subclass(weighted_first):
+    class HigherPriorityObject(pd.DataFrame):
+        __array_priority__ = MicroSeries.__array_priority__ + 1
+
+    source = pd.Series([10, 20])
+    weighted = MicroSeries(source, weights=[2, 9])
+    higher = HigherPriorityObject([12, 10])
+    plain_inputs = (source, higher) if weighted_first else (higher, source)
+    inputs = (weighted, higher) if weighted_first else (higher, weighted)
+
+    # Test the deferral protocol directly: the foreign handler decides how
+    # to handle the operation after MicroSeries returns NotImplemented.
+    assert (
+        source.__array_ufunc__(np.maximum, "__call__", *plain_inputs) is NotImplemented
+    )
+    assert weighted.__array_ufunc__(np.maximum, "__call__", *inputs) is NotImplemented
+
+
+@pytest.mark.parametrize("ufunc", [np.divmod, np.maximum, np.add])
+@pytest.mark.parametrize("weighted_first", [True, False])
+def test_binary_ufunc_preserves_pandas_result_metadata(ufunc, weighted_first):
+    source = pd.Series([10, 20], index=["b", "a"], name="income")
+    other = pd.Series([23, 41], index=["a", "b"], name="income")
+    source.attrs = {"units": {"currency": "USD"}}
+    other.attrs = {"units": {"currency": "EUR"}}
+    weighted = MicroSeries(source, weights=[2, 9])
+    weighted.attrs = source.attrs.copy()
+    plain_inputs = (source, other) if weighted_first else (other, source)
+    inputs = (weighted, other) if weighted_first else (other, weighted)
+    expected = ufunc(*plain_inputs)
+
+    actual = ufunc(*inputs)
+
+    if not isinstance(expected, tuple):
+        actual, expected = (actual,), (expected,)
+    for result, plain in zip(actual, expected):
+        pd.testing.assert_series_equal(pd.Series(result), plain)
+        assert result.attrs == plain.attrs
+        if result.attrs:
+            result.attrs["units"]["currency"] = "changed"
+    assert source.attrs == weighted.attrs == {"units": {"currency": "USD"}}
+    assert other.attrs == {"units": {"currency": "EUR"}}
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+@pytest.mark.parametrize("other_labels", [["b", "a"], ["a", "b"]])
+def test_maximum_with_inherited_higher_priority_series_completes(
+    weighted_first, other_labels
+):
+    class HigherPrioritySeries(pd.Series):
+        __array_priority__ = MicroSeries.__array_priority__ + 1
+
+    source = pd.Series(
+        [10, 20], index=pd.Index(["b", "a"], name="person"), name="income"
+    )
+    source.attrs = {"units": {"currency": "USD"}}
+    other = HigherPrioritySeries(
+        [12.5, 10.5],
+        index=pd.Index(other_labels, name="person"),
+        name="income",
+    )
+    other.attrs = {"units": {"currency": "EUR"}}
+    weighted = MicroSeries(source, weights=[2, 9])
+    weighted.attrs = source.attrs.copy()
+    plain_inputs = (source, other) if weighted_first else (other, source)
+    inputs = (weighted, other) if weighted_first else (other, weighted)
+    expected = np.maximum(*plain_inputs)
+    weights = pd.Series([2.0, 9.0], index=source.index).reindex(expected.index)
+
+    result = np.maximum(*inputs)
+
+    assert isinstance(result, MicroSeries)
+    pd.testing.assert_series_equal(pd.Series(result), expected)
+    pd.testing.assert_series_equal(result.weights, weights)
+    assert result.attrs == expected.attrs
+    assert result.sum() == expected.multiply(weights).sum()
+    result.weights.iloc[0] = 100
+    pd.testing.assert_series_equal(
+        weighted.weights, pd.Series([2.0, 9.0], index=source.index)
+    )
+    weighted.weights.iloc[-1] = 200
+    assert result.weights.iloc[-1] == weights.iloc[-1]
+    assert source.attrs == weighted.attrs == {"units": {"currency": "USD"}}
+    assert other.attrs == {"units": {"currency": "EUR"}}
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+def test_higher_priority_inherited_series_preserves_masked_out(weighted_first):
+    class HigherPrioritySeries(pd.Series):
+        __array_priority__ = MicroSeries.__array_priority__ + 1
+
+    source = pd.Series([10.0, 20.0], index=["b", "a"], name="income")
+    other = HigherPrioritySeries([12.0, 10.0], index=source.index, name="income")
+    weighted = MicroSeries(source, weights=[2, 9])
+    out = np.full(2, -99.0)
+    plain_out = out.copy()
+    plain_inputs = (source, other) if weighted_first else (other, source)
+    inputs = (weighted, other) if weighted_first else (other, weighted)
+    expected = np.maximum(*plain_inputs, out=plain_out, where=[True, False])
+
+    result = np.maximum(*inputs, out=out, where=[True, False])
+
+    assert (result is out) == (expected is plain_out)
+    np.testing.assert_array_equal(out, [12.0, -99.0])
+    np.testing.assert_array_equal(out, plain_out)
+    pd.testing.assert_series_equal(pd.Series(result), expected)
+    assert result.attrs == expected.attrs
+    assert np.shares_memory(np.asarray(result), out) == np.shares_memory(
+        np.asarray(expected), plain_out
+    )
+
+
+@pytest.mark.parametrize("ufunc", [np.maximum, np.minimum, np.fmax])
+@pytest.mark.parametrize("weighted_first", [True, False])
+def test_inherited_priority_series_preserves_unsorted_dispatch_order(
+    ufunc, weighted_first
+):
+    class HigherPrioritySeries(pd.Series):
+        __array_priority__ = MicroSeries.__array_priority__ + 1
+
+    source = pd.Series(
+        [6.0, 18.0, 30.0], index=pd.Index(["b", "a", "c"], name="row"), name="amount"
+    )
+    other = HigherPrioritySeries(
+        [9.0, 15.0, 45.0], index=pd.Index(["c", "a", "b"], name="row"), name="amount"
+    )
+    weighted = MicroSeries(source, weights=[7, 2, 5])
+    plain_inputs = (source, other) if weighted_first else (other, source)
+    inputs = (weighted, other) if weighted_first else (other, weighted)
+    expected = ufunc(*plain_inputs)
+    weights = pd.Series([7.0, 2.0, 5.0], index=source.index).reindex(expected.index)
+
+    result = ufunc(*inputs)
+
+    assert expected.index.tolist() == (
+        ["c", "a", "b"] if weighted_first else ["a", "b", "c"]
+    )
+    assert isinstance(result, MicroSeries)
+    pd.testing.assert_series_equal(pd.Series(result), expected)
+    pd.testing.assert_series_equal(result.weights, weights)
+    assert result.sum() == expected.multiply(weights).sum()
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+@pytest.mark.parametrize("output_kind", ["array", "series", "micro", "none"])
+def test_inherited_priority_output_preserves_unsorted_dispatch_order(
+    weighted_first, output_kind
+):
+    class HigherPrioritySeries(pd.Series):
+        __array_priority__ = MicroSeries.__array_priority__ + 1
+
+    source = pd.Series([6.0, 18.0, 30.0], index=["b", "a", "c"], name="amount")
+    other = HigherPrioritySeries(
+        [9.0, 15.0, 45.0], index=["c", "a", "b"], name="amount"
+    )
+    weighted = MicroSeries(source, weights=[7, 2, 5])
+    plain_inputs = (source, other) if weighted_first else (other, source)
+    inputs = (weighted, other) if weighted_first else (other, weighted)
+    kwargs = {}
+    if output_kind == "array":
+        out = np.full(3, -77.0)
+        plain_out = out.copy()
+        kwargs["where"] = [True, False, True]
+    elif output_kind in ("series", "micro"):
+        plain_out = pd.Series([-77.0] * 3, index=source.index, name="destination")
+        out = (
+            MicroSeries(plain_out, weights=[19, 23, 29])
+            if output_kind == "micro"
+            else plain_out.copy()
+        )
+    else:
+        out = plain_out = None
+    expected = np.maximum(*plain_inputs, out=plain_out, **kwargs)
+
+    result = np.maximum(*inputs, out=out, **kwargs)
+
+    assert expected.index.tolist() == (
+        ["c", "a", "b"] if weighted_first else ["a", "b", "c"]
+    )
+    pd.testing.assert_series_equal(pd.Series(result), expected)
+    if out is not None:
+        np.testing.assert_array_equal(np.asarray(out), np.asarray(plain_out))
+        assert (result is out) == (expected is plain_out)
+        assert np.shares_memory(
+            np.asarray(result), np.asarray(out)
+        ) == np.shares_memory(np.asarray(expected), np.asarray(plain_out))
+    if output_kind == "array":
+        np.testing.assert_array_equal(
+            out, [30.0, -77.0, 45.0] if weighted_first else [18.0, -77.0, 30.0]
+        )
+    if output_kind == "micro":
+        np.testing.assert_array_equal(out.weights, [19, 23, 29])
+    np.testing.assert_array_equal(weighted.weights, [7, 2, 5])
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+def test_inherited_priority_series_rejects_unknown_row_weights(weighted_first):
+    class HigherPrioritySeries(pd.Series):
+        __array_priority__ = MicroSeries.__array_priority__ + 1
+
+    source = pd.Series([6, 18, 30], index=["b", "a", "c"])
+    other = HigherPrioritySeries([9, 15, 45], index=["c", "a", "unknown"])
+    weighted = MicroSeries(source, weights=[7, 2, 5])
+    plain_inputs = (source, other) if weighted_first else (other, source)
+    inputs = (weighted, other) if weighted_first else (other, weighted)
+    # Values are defined by pandas, but the extra row has no observation weight.
+    np.maximum(*plain_inputs)
+
+    with pytest.raises(ValueError, match="weights"):
+        np.maximum(*inputs)
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+@pytest.mark.parametrize(
+    "row_error,output_kind,masked",
+    [
+        ("unknown-input", "input", False),
+        ("unknown-input", "array", False),
+        ("unknown-input", "array", True),
+        ("unknown-input", "series", False),
+        ("unknown-input", "micro", False),
+        ("unknown-output", "micro", False),
+        ("ambiguous-output", "micro", False),
+    ],
+)
+def test_inherited_priority_row_rejection_preserves_inputs_and_outputs(
+    weighted_first, row_error, output_kind, masked
+):
+    class HigherPrioritySeries(pd.Series):
+        __array_priority__ = MicroSeries.__array_priority__ + 1
+
+    source = pd.Series(
+        [1.0, 2.0, 4.0], index=pd.Index(["b", "a", "c"], name="row"), name="amount"
+    )
+    weighted = MicroSeries(source, weights=[3, 7, 11])
+    weighted.attrs = {"units": {"currency": "USD"}}
+    other_labels = (
+        ["b", "a", "unknown"] if row_error == "unknown-input" else source.index
+    )
+    higher = HigherPrioritySeries([9.0, 8.0, 6.0], index=other_labels, name="amount")
+    inputs = (weighted, higher) if weighted_first else (higher, weighted)
+    result_index = higher.index if weighted_first else source.index.union(higher.index)
+    if output_kind == "input":
+        out = weighted
+    elif output_kind == "array":
+        out = np.full(len(result_index), -99.0)
+    else:
+        output_labels = (
+            ["b", "a", "unknown"]
+            if row_error == "unknown-output"
+            else ["b", "a", "a"]
+            if row_error == "ambiguous-output"
+            else result_index
+        )
+        destination = pd.Series(-99.0, index=output_labels, name="destination")
+        out = (
+            MicroSeries(destination, weights=np.arange(len(destination)) + 19)
+            if output_kind == "micro"
+            else destination
+        )
+        out.attrs = {"purpose": "unchanged"}
+    original_output = np.array(out, copy=True)
+    original_weights = weighted.weights.copy()
+    output_weights = out.weights.copy() if isinstance(out, MicroSeries) else None
+    original_index = out.index.copy() if isinstance(out, pd.Series) else None
+    original_attrs = out.attrs.copy() if isinstance(out, pd.Series) else None
+    kwargs = {"where": np.arange(len(out)) % 2 == 0} if masked else {}
+
+    with pytest.raises(ValueError):
+        np.maximum(*inputs, out=out, **kwargs)
+
+    pd.testing.assert_series_equal(pd.Series(weighted), source)
+    pd.testing.assert_series_equal(weighted.weights, original_weights)
+    assert weighted.attrs == {"units": {"currency": "USD"}}
+    assert weighted.sum() == 61  # 1 * 3 + 2 * 7 + 4 * 11.
+    np.testing.assert_array_equal(np.asarray(out), original_output)
+    if isinstance(out, pd.Series):
+        pd.testing.assert_index_equal(out.index, original_index)
+        assert out.attrs == original_attrs
+        assert out.name == ("amount" if output_kind == "input" else "destination")
+    if output_weights is not None:
+        pd.testing.assert_series_equal(out.weights, output_weights)
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+def test_inherited_priority_valid_aliased_output_matches_pandas(weighted_first):
+    class HigherPrioritySeries(pd.Series):
+        __array_priority__ = MicroSeries.__array_priority__ + 1
+
+    source = pd.Series([6.0, 18.0, 30.0], index=["b", "a", "c"], name="amount")
+    higher = HigherPrioritySeries(
+        [9.0, 15.0, 45.0], index=["c", "a", "b"], name="amount"
+    )
+    weighted = MicroSeries(source.copy(), weights=[7, 2, 5])
+    plain_inputs = (source, higher) if weighted_first else (higher, source)
+    inputs = (weighted, higher) if weighted_first else (higher, weighted)
+    expected = np.maximum(*plain_inputs, out=source)
+
+    result = np.maximum(*inputs, out=weighted)
+
+    pd.testing.assert_series_equal(pd.Series(weighted), source)
+    pd.testing.assert_series_equal(pd.Series(result), expected)
+    pd.testing.assert_series_equal(
+        weighted.weights, pd.Series([7.0, 2.0, 5.0], index=source.index)
+    )
+    assert (result is weighted) == (expected is source)
+    assert np.shares_memory(
+        np.asarray(result), np.asarray(weighted)
+    ) == np.shares_memory(np.asarray(expected), np.asarray(source))
+
+
+@pytest.mark.parametrize("weighted_first", [True, False])
+def test_foreign_ufunc_handler_receives_out_before_weight_validation(weighted_first):
+    calls = []
+    sentinel = object()
+
+    class ForeignSeries(pd.Series):
+        __array_priority__ = MicroSeries.__array_priority__ + 1
+
+        def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+            calls.append((ufunc, method, inputs, kwargs))
+            return sentinel
+
+    weighted = MicroSeries([1.0, 2.0], index=["a", "b"], weights=[3, 7])
+    other = ForeignSeries([9.0, 8.0], index=["a", "unknown"])
+    inputs = (weighted, other) if weighted_first else (other, weighted)
+    out = np.full(2, -99.0)
+
+    assert np.maximum(*inputs, out=out) is sentinel
+
+    assert len(calls) == 1
+    ufunc, method, received_inputs, kwargs = calls[0]
+    assert ufunc is np.maximum and method == "__call__"
+    assert all(actual is expected for actual, expected in zip(received_inputs, inputs))
+    assert kwargs["out"][0] is out
+    np.testing.assert_array_equal(out, [-99.0, -99.0])

{microdf_python-1.5.0 → microdf_python-1.5.2/microdf_python.egg-info}/PKG-INFO

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

{microdf_python-1.5.0 → microdf_python-1.5.2}/microdf_python.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ microdf/microseries.py
 microdf/replication.py
 microdf/tests/conftest.py
 microdf/tests/test_aggregation_errors.py
+microdf/tests/test_binary_weight_alignment.py
 microdf/tests/test_dataframe_weight_storage.py
 microdf/tests/test_microseries_dataframe.py
 microdf/tests/test_nullify_weights_index.py
@@ -16,6 +17,7 @@ microdf/tests/test_quantile_missing_values.py
 microdf/tests/test_replication.py
 microdf/tests/test_serialization.py
 microdf/tests/test_sum_axes.py
+microdf/tests/test_ufunc_weight_dispatch.py
 microdf/tests/test_version_metadata.py
 microdf/tests/test_weight_propagation.py
 microdf/tests/test_weighted_cov_corr.py

{microdf_python-1.5.0 → microdf_python-1.5.2}/pyproject.toml

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