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

microdf/tests/test_microseries_dataframe.py

@@ -2,6 +2,7 @@ import warnings
 
 import numpy as np
 import pandas as pd
+import pytest
 
 import microdf as mdf
 from microdf.microdataframe import MicroDataFrame
@@ -261,9 +262,7 @@ def test_decile_rank() -> None:
 
 
 def test_copy_equals() -> None:
-    d = mdf.MicroDataFrame(
-        {"x": [1, 2], "y": [3, 4], "z": [5, 6]}, weights=[7, 8]
-    )
+    d = mdf.MicroDataFrame({"x": [1, 2], "y": [3, 4], "z": [5, 6]}, weights=[7, 8])
     d_copy = d.copy()
     d_copy_diff_weights = d_copy.copy()
     d_copy_diff_weights.weights *= 2
@@ -275,9 +274,7 @@ def test_copy_equals() -> None:
 
 
 def test_subset() -> None:
-    df = mdf.MicroDataFrame(
-        {"x": [1, 2], "y": [3, 4], "z": [5, 6]}, weights=[7, 8]
-    )
+    df = mdf.MicroDataFrame({"x": [1, 2], "y": [3, 4], "z": [5, 6]}, weights=[7, 8])
     df_no_z = mdf.MicroDataFrame({"x": [1, 2], "y": [3, 4]}, weights=[7, 8])
     assert df[["x", "y"]].equals(df_no_z)
     df_no_z_diff_weights = df_no_z.copy()
@@ -353,9 +350,7 @@ def test_reset_index_inplace() -> None:
     # Test 4: Multi-level index
     arrays = [["bar", "bar", "baz", "baz"], ["one", "two", "one", "two"]]
     multi_index = pd.MultiIndex.from_arrays(arrays, names=["first", "second"])
-    df_multi = pd.DataFrame(
-        {"A": [1, 2, 3, 4], "B": [5, 6, 7, 8]}, index=multi_index
-    )
+    df_multi = pd.DataFrame({"A": [1, 2, 3, 4], "B": [5, 6, 7, 8]}, index=multi_index)
     mdf_multi = MicroDataFrame(df_multi, weights=weights)
     result = mdf_multi.reset_index(level="first")
     assert "first" in result.columns
@@ -373,9 +368,7 @@ def test_reset_index_inplace() -> None:
 def test_loc_preserves_weights() -> None:
     """Test that .loc[] returns MicroDataFrame with proper weights (issue
     #265)."""
-    df = mdf.MicroDataFrame(
-        {"one": [1, 1, 1, 1, 1]}, weights=[10, 20, 30, 40, 50]
-    )
+    df = mdf.MicroDataFrame({"one": [1, 1, 1, 1, 1]}, weights=[10, 20, 30, 40, 50])
 
     # Filter all rows (should get same weights)
     filtered = df.loc[df.one == 1]
@@ -383,9 +376,7 @@ def test_loc_preserves_weights() -> None:
     assert filtered.one.sum() == 150.0  # Weighted sum
 
     # Partial filter
-    df2 = mdf.MicroDataFrame(
-        {"x": [1, 2, 3, 4, 5]}, weights=[10, 20, 30, 40, 50]
-    )
+    df2 = mdf.MicroDataFrame({"x": [1, 2, 3, 4, 5]}, weights=[10, 20, 30, 40, 50])
     subset = df2.loc[df2.x > 2]
     assert isinstance(subset, MicroDataFrame)
     assert subset.x.sum() == 500.0  # 3*30 + 4*40 + 5*50 = 500
@@ -394,9 +385,7 @@ def test_loc_preserves_weights() -> None:
 
 def test_iloc_preserves_weights() -> None:
     """Test that .iloc[] returns MicroDataFrame with proper weights."""
-    df = mdf.MicroDataFrame(
-        {"x": [1, 2, 3, 4, 5]}, weights=[10, 20, 30, 40, 50]
-    )
+    df = mdf.MicroDataFrame({"x": [1, 2, 3, 4, 5]}, weights=[10, 20, 30, 40, 50])
 
     # Select rows by position
     subset = df.iloc[2:5]
@@ -407,9 +396,7 @@ def test_iloc_preserves_weights() -> None:
 
 def test_groupby_column_selection() -> None:
     """Test that groupby column selection preserves weights (issue #193)."""
-    d = mdf.MicroDataFrame(
-        dict(g=["a", "a", "b"], y=[1, 2, 3]), weights=[4, 5, 6]
-    )
+    d = mdf.MicroDataFrame(dict(g=["a", "a", "b"], y=[1, 2, 3]), weights=[4, 5, 6])
 
     # Test single column string selection
     result_str = d.groupby("g")["y"].sum()
@@ -459,6 +446,43 @@ def test_mean_no_warning() -> None:
         assert len(user_warnings) == 0
 
 
+def test_sum_with_non_default_index() -> None:
+    """Weighted sum must not silently return 0 with a non-default index.
+
+    Regression test for the bug where ``set_weights`` stored the weights
+    Series with a default ``RangeIndex`` regardless of ``self.index``.
+    Element-wise ops like ``self.multiply(self.weights)`` then aligned on
+    label, producing all-NaN and a silent ``0.0`` from ``.sum()`` while
+    ``.mean()`` (which uses a positional ndarray) stayed correct.
+    """
+    # MicroSeries with custom integer index.
+    s = mdf.MicroSeries([1, 2, 3], index=[100, 200, 300], weights=[10, 20, 30])
+    assert s.sum() == 140.0
+    assert s.weights.index.tolist() == [100, 200, 300]
+
+    # MicroDataFrame with custom integer index.
+    df = mdf.MicroDataFrame(
+        {"x": [1, 2, 3]}, index=[100, 200, 300], weights=[10, 20, 30]
+    )
+    assert df.x.sum() == 140.0
+    assert df.weights.index.tolist() == [100, 200, 300]
+
+    # MicroDataFrame with string index + set_weights via column name.
+    df2 = mdf.MicroDataFrame(
+        {"x": [1, 2, 3], "w": [10, 20, 30]},
+        index=["a", "b", "c"],
+    )
+    df2.set_weights("w")
+    assert df2.x.sum() == 140.0
+    assert df2.weights.index.tolist() == ["a", "b", "c"]
+
+    # Passing a Series with its own index should position-align, not
+    # label-align, so sum does not depend on accidental index alignment.
+    df3 = mdf.MicroDataFrame({"x": [1, 2, 3]}, index=[100, 200, 300])
+    df3.set_weights(pd.Series([10, 20, 30], index=[0, 1, 2]))
+    assert df3.x.sum() == 140.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])
@@ -467,3 +491,331 @@ def test_repr_no_warning() -> None:
         _ = repr(ms)
         user_warnings = [x for x in w if issubclass(x.category, UserWarning)]
         assert len(user_warnings) == 0
+
+
+def test_drop_inplace_aligns_weights() -> None:
+    """Regression: ``drop(inplace=True)`` must keep weights in sync.
+
+    Previously, ``weights_backup = self.weights.copy()`` was taken *before*
+    the drop, then reassigned back afterwards — so the weights vector
+    kept its original length and any subsequent weighted op either
+    raised a length-mismatch ValueError or silently returned 0.
+    """
+    # Row drop inplace.
+    df = mdf.MicroDataFrame({"x": [1, 2, 3, 4]}, weights=[10, 20, 30, 40])
+    df.drop(index=[0, 1], inplace=True)
+    assert len(df) == len(df.weights) == 2
+    assert df.x.sum() == 3 * 30 + 4 * 40  # 250
+
+    # Row drop non-inplace.
+    df = mdf.MicroDataFrame({"x": [1, 2, 3, 4]}, weights=[10, 20, 30, 40])
+    df2 = df.drop(index=[0, 1])
+    assert len(df2) == len(df2.weights) == 2
+    assert df2.x.sum() == 250
+    # Original untouched.
+    assert len(df) == 4
+    assert df.x.sum() == 1 * 10 + 2 * 20 + 3 * 30 + 4 * 40
+
+    # Column drop (weights length unchanged).
+    df = mdf.MicroDataFrame({"x": [1, 2, 3], "y": [4, 5, 6]}, weights=[10, 20, 30])
+    df.drop(columns=["y"], inplace=True)
+    assert list(df.columns) == ["x"]
+    assert df.x.sum() == 1 * 10 + 2 * 20 + 3 * 30
+
+    # String index row drop.
+    df = mdf.MicroDataFrame(
+        {"x": [1, 2, 3, 4]},
+        index=["a", "b", "c", "d"],
+        weights=[10, 20, 30, 40],
+    )
+    df.drop(index=["a", "b"], inplace=True)
+    assert df.x.sum() == 250
+
+    # labels= with default axis=0.
+    df = mdf.MicroDataFrame({"x": [1, 2, 3, 4]}, weights=[10, 20, 30, 40])
+    df.drop(labels=[0, 1], inplace=True)
+    assert df.x.sum() == 250
+
+
+def test_merge_preserves_weights_per_surviving_row() -> None:
+    """Regression: merge must propagate weights onto the merged rows.
+
+    Previously the implementation passed ``self.weights`` straight to the
+    MicroDataFrame constructor, so any merge that changed row count
+    (inner filtering, left-with-missing, many-to-many, outer) raised
+    ``ValueError: Length of weights (N) does not match length of
+    DataFrame (M)``.
+    """
+    # Inner join filters rows.
+    left = mdf.MicroDataFrame(
+        {"k": [1, 2, 3, 4], "v": [10, 20, 30, 40]}, weights=[1, 2, 3, 4]
+    )
+    right = pd.DataFrame({"k": [2, 4], "w": [20, 40]})
+    res = left.merge(right, on="k")
+    assert len(res) == 2
+    # k=2 carries weight 2; k=4 carries weight 4.
+    np.testing.assert_array_equal(sorted(res.weights.values), [2.0, 4.0])
+    assert res.v.sum() == 2 * 20 + 4 * 40
+
+    # Left join with missing from right.
+    left = mdf.MicroDataFrame(
+        {"k": [1, 2, 3, 4], "v": [10, 20, 30, 40]}, weights=[1, 2, 3, 4]
+    )
+    right = pd.DataFrame({"k": [2, 4], "w": [100, 200]})
+    res = left.merge(right, on="k", how="left")
+    assert len(res) == 4
+    assert res.v.sum() == 300  # 1*10 + 2*20 + 3*30 + 4*40
+
+    # Many-to-many duplicates left rows; the same weight should ride
+    # along on each duplicate.
+    left = mdf.MicroDataFrame({"k": [1, 2], "v": [10, 20]}, weights=[5, 7])
+    right = pd.DataFrame({"k": [1, 1, 2], "w": [100, 200, 300]})
+    res = left.merge(right, on="k")
+    assert len(res) == 3
+    # v=10 weighted 5 appears twice, v=20 weighted 7 appears once.
+    assert res.v.sum() == 10 * 5 + 10 * 5 + 20 * 7
+
+    # Outer join: right-only rows have no left weight. We default to 0
+    # so they don't silently poison downstream aggregations.
+    left = mdf.MicroDataFrame({"k": [1, 2], "v": [10, 20]}, weights=[1, 2])
+    right = pd.DataFrame({"k": [2, 3], "w": [20, 30]})
+    res = left.merge(right, on="k", how="outer")
+    # k=1 -> weight 1, k=2 -> weight 2, k=3 -> weight 0 (right-only).
+    assert sorted(res.weights.values) == [0.0, 1.0, 2.0]
+
+
+def test_groupby_does_not_leak_tmp_weights_column() -> None:
+    """Regression: groupby used to mutate self by adding __tmp_weights.
+
+    Previously, ``MicroDataFrame.groupby`` set ``self["__tmp_weights"]``
+    and never cleaned it up, so ``df.columns`` afterwards included the
+    weight column and any later ``df.sum()`` or iteration over columns
+    picked it up as data.
+    """
+    df = mdf.MicroDataFrame({"g": ["a", "a", "b"], "v": [1, 2, 3]}, weights=[1, 2, 3])
+    original_cols = list(df.columns)
+    _ = df.groupby("g").sum()
+    assert list(df.columns) == original_cols
+    assert "__tmp_weights" not in df.columns
+
+    # Groupby by a list of columns should also not leak.
+    df2 = mdf.MicroDataFrame(
+        {"g1": ["a", "a", "b"], "g2": [1, 1, 2], "v": [1, 2, 3]},
+        weights=[1, 2, 3],
+    )
+    orig2 = list(df2.columns)
+    _ = df2.groupby(["g1", "g2"]).v.sum()
+    assert list(df2.columns) == orig2
+
+    # Weighted aggregation is still correct after the fix.
+    result = df.groupby("g").v.sum()
+    assert result["a"] == 1 * 1 + 2 * 2
+    assert result["b"] == 3 * 3
+
+
+def test_quantile_skips_zero_weight_rows() -> None:
+    """Regression: quantile(0) shouldn't pick a zero-weight element.
+
+    Previously, ``np.searchsorted(cumsum_norm, 0, side='left')`` returned
+    0 even when that first sorted element had zero weight, so
+    ``MicroSeries([10, 20, 30], weights=[0, 1, 1]).quantile(0)`` returned
+    10 instead of 20. The fix drops zero-weight rows before computing
+    the CDF.
+    """
+    s = mdf.MicroSeries([10, 20, 30], weights=[0, 1, 1])
+    assert s.quantile(0.0) == 20
+    assert s.quantile(0.5) == 20
+    assert s.quantile(1.0) == 30
+
+    # Internal plateau of zero weight.
+    s = mdf.MicroSeries([10, 20, 30, 40], weights=[1, 0, 1, 1])
+    assert s.quantile(0.0) == 10
+    # Post-filter values [10, 30, 40] with equal weights -> cum=[.33,.67,1].
+    # 0.4 -> smallest cum >= 0.4 is index 1 -> value 30.
+    assert s.quantile(0.4) == 30
+    # The zero-weight value (20) should never be selected.
+    for q in np.linspace(0, 1, 21):
+        assert s.quantile(q) != 20
+
+    # All zero weights -> NaN (defined behaviour).
+    s = mdf.MicroSeries([10, 20, 30], weights=[0, 0, 0])
+    assert np.isnan(s.quantile(0.5))
+
+
+def test_top_x_pct_share_handles_ties_and_edges() -> None:
+    """Regression: top_x_pct_share double-counted threshold ties.
+
+    Old implementation: ``self[self >= threshold].sum() / self.sum()``.
+    With constant values every call returned 1.0 regardless of the
+    requested top percent; ``top_x_pct_share(0)`` returned the share of
+    the max bucket instead of 0.
+    """
+    # Constant values: the top p% should hold exactly p% of the total.
+    for p in [0.0, 0.01, 0.1, 0.5, 1.0]:
+        got = mdf.MicroSeries([5] * 10, weights=[1] * 10).top_x_pct_share(p)
+        assert np.isclose(got, p), f"top={p}, got {got}"
+
+    # Non-constant, equal weights.
+    s = mdf.MicroSeries(list(range(1, 11)), weights=[1] * 10)
+    # Sum 1..10 = 55. Top 10% = top 1 row = 10 -> 10/55.
+    assert np.isclose(s.top_x_pct_share(0.1), 10 / 55)
+    # Top 50% = rows 6..10 -> 40/55.
+    assert np.isclose(s.top_x_pct_share(0.5), 40 / 55)
+    # Top 0% = 0, top 100% = 1.
+    assert s.top_x_pct_share(0.0) == 0.0
+    assert s.top_x_pct_share(1.0) == 1.0
+
+    # Bottom share complements the top share.
+    assert np.isclose(s.bottom_x_pct_share(0.1), 1 - s.top_x_pct_share(0.9))
+
+    # Ties with unequal totals.
+    s_ties = mdf.MicroSeries([1, 1, 10, 10], weights=[1, 1, 1, 1])
+    # Top 50% = the two 10s -> 20/22.
+    assert np.isclose(s_ties.top_x_pct_share(0.5), 20 / 22)
+
+    # Downstream helpers still work.
+    assert np.isclose(s_ties.top_10_pct_share(), s_ties.top_x_pct_share(0.1))
+    assert np.isclose(s_ties.top_50_pct_share(), s_ties.top_x_pct_share(0.5))
+
+
+def test_gini_negatives_option_applied() -> None:
+    """Regression: gini(negatives=...) was silently ignored.
+
+    Both branches of the old implementation sorted ``self`` directly
+    rather than the local ``x`` that was mutated by the ``negatives``
+    option, so ``negatives='zero'`` and ``negatives='shift'`` did
+    nothing.
+    """
+    s = mdf.MicroSeries([-5, 0, 10], weights=[1, 1, 1])
+
+    # Leaving negatives in place now warns.
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = s.gini()
+        user_warnings = [x for x in w if issubclass(x.category, UserWarning)]
+        assert len(user_warnings) == 1
+        assert "negative" in str(user_warnings[0].message).lower()
+
+    # 'zero' clamps negatives. Values become [0, 0, 10] with equal
+    # weights; closed-form gini = 2/3.
+    assert np.isclose(s.gini(negatives="zero"), 2 / 3)
+
+    # 'shift' adds |min|. Values become [0, 5, 15]; Gini in [0, 1].
+    shifted = s.gini(negatives="shift")
+    assert 0 <= shifted <= 1
+
+    # All-zero short-circuits to 0 instead of nan/RuntimeWarning.
+    assert mdf.MicroSeries([0, 0, 0], weights=[1, 2, 3]).gini() == 0.0
+
+    # Invalid negatives arg raises.
+    with pytest.raises(ValueError):
+        mdf.MicroSeries([1, 2, 3], weights=[1, 1, 1]).gini(negatives="bogus")
+
+
+def test_std_var_are_weighted() -> None:
+    """Regression: std/var used to silently fall through to pandas.
+
+    The old implementation had no override, so a MicroSeries with very
+    uneven weights returned the unweighted 1.0. Now std and var treat
+    the weights as frequency counts, matching numpy on the replicated
+    sample.
+    """
+    s = mdf.MicroSeries([1, 2, 3], weights=[100, 1, 1])
+    # Unweighted would be 1.0. Weighted std pulls toward the heavy row.
+    assert s.std() < 1.0
+    assert s.var() < 1.0
+
+    # Integer-replication equivalence.
+    s = mdf.MicroSeries([1, 2, 3], weights=[2, 3, 1])
+    rep = np.array([1, 1, 2, 2, 2, 3])
+    assert np.isclose(s.std(), np.std(rep, ddof=1))
+    assert np.isclose(s.var(), np.var(rep, ddof=1))
+    assert np.isclose(s.var(ddof=0), np.var(rep, ddof=0))
+
+    # NaN handling.
+    s = mdf.MicroSeries([1.0, np.nan, 3.0], weights=[2, 3, 1])
+    assert not np.isnan(s.std())
+    assert np.isnan(s.std(skipna=False))
+
+    # DataFrame dispatch: df.std() / df.var() now return weighted stats.
+    df = mdf.MicroDataFrame({"x": [1, 2, 3], "y": [10, 20, 30]}, weights=[2, 3, 1])
+    np.testing.assert_allclose(
+        df.std().values,
+        [
+            np.std(rep, ddof=1),
+            np.std(np.array([10, 10, 20, 20, 20, 30]), ddof=1),
+        ],
+    )
+
+
+def test_cov_corr_warn_when_fallthrough() -> None:
+    """Regression: cov/corr silently returned unweighted pandas values.
+
+    They still fall through to pandas (a weighted impl is a separate
+    issue) but now emit a UserWarning so callers aren't misled.
+    """
+    s1 = mdf.MicroSeries([1, 2, 3], weights=[1, 1, 1])
+    s2 = mdf.MicroSeries([2, 4, 6], weights=[1, 1, 1])
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = s1.cov(s2)
+        msgs = [str(x.message) for x in w if issubclass(x.category, UserWarning)]
+        assert any("unweighted" in m.lower() for m in msgs)
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = s1.corr(s2)
+        msgs = [str(x.message) for x in w if issubclass(x.category, UserWarning)]
+        assert any("unweighted" in m.lower() for m in msgs)
+
+
+def test_count_skips_nan_by_default() -> None:
+    """Regression: ``count()`` included NaN-row weight, contrary to pandas.
+
+    Pandas ``Series.count`` skips NaN; MicroSeries returned the full
+    weight sum regardless. The fix matches pandas semantics and adds a
+    ``skipna`` kwarg so callers can opt out.
+    """
+    s = mdf.MicroSeries([1.0, np.nan, 3.0], weights=[10, 20, 30])
+    assert s.count() == 40.0
+    assert s.count(skipna=True) == 40.0
+    assert s.count(skipna=False) == 60.0
+
+    # No NaN: skipna is a no-op.
+    assert mdf.MicroSeries([1, 2, 3], weights=[2, 3, 4]).count() == 9.0
+
+    # All NaN: count skips everything.
+    all_nan = mdf.MicroSeries([np.nan] * 3, weights=[1, 2, 3])
+    assert all_nan.count() == 0.0
+    assert all_nan.count(skipna=False) == 6.0
+
+
+def test_rank_ties_share_bucket() -> None:
+    """Regression: rank used to assign ties to different ranks/buckets.
+
+    Previously ``rank`` returned the running cumulative weight in sort
+    order, so every row — tied or not — got a distinct value. As a
+    result ``MicroSeries([5]*5, weights=[1]*5).decile_rank()`` returned
+    ``[2, 4, 6, 8, 10]`` rather than all 10. With max-rank semantics,
+    tied values share the cumulative weight at the end of their tie
+    group, so bucketing is stable under ties.
+    """
+    # All tied: every element lands in the top decile.
+    s = mdf.MicroSeries([5] * 5, weights=[1] * 5)
+    np.testing.assert_array_equal(s.rank().values, [5, 5, 5, 5, 5])
+    np.testing.assert_array_equal(s.decile_rank().values, [10] * 5)
+    np.testing.assert_array_equal(s.quintile_rank().values, [5] * 5)
+
+    # Partial ties.
+    s = mdf.MicroSeries([1, 2, 2, 3], weights=[1, 1, 1, 1])
+    np.testing.assert_array_equal(s.rank().values, [1, 3, 3, 4])
+
+    # pct=True normalizes to (0, 1] and still shares ranks on ties.
+    s = mdf.MicroSeries([5] * 4, weights=[1] * 4)
+    np.testing.assert_allclose(s.rank(pct=True).values, [1.0, 1.0, 1.0, 1.0])
+
+    # Non-ties still match the old cumulative-weight behaviour, so the
+    # existing ``test_rank`` expectations hold.
+    s = mdf.MicroSeries([1, 2, 3], weights=[4, 5, 6])
+    np.testing.assert_array_equal(s.rank().values, [4, 9, 15])

microdf/tests/test_pandas3_compatibility.py

@@ -38,23 +38,23 @@ class TestMicroSeriesSubclassPreservation:
 
         # 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
@@ -63,35 +63,33 @@ class TestMicroSeriesSubclassPreservation:
 
         # 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])
-        )
+        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:
@@ -105,9 +103,7 @@ class TestMicroDataFrameSubclassPreservation:
 
         # 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")
 
@@ -120,9 +116,9 @@ class TestMicroDataFrameSubclassPreservation:
 
         # 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")
 
 
@@ -186,9 +182,7 @@ class TestCopyOnWriteCompatibility:
 
     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 = MicroDataFrame({"a": [1, 2, 3]}, weights=np.array([1.0, 2.0, 3.0]))
         mdf_copy = mdf.copy()
 
         # Modify original

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.2.2
+Version: 1.3.0
 Summary: Weighted pandas DataFrames and Series for survey microdata
 Author-email: Max Ghenis <max@policyengine.org>
 License: MIT
@@ -11,12 +11,8 @@ Requires-Dist: numpy
 Requires-Dist: pandas
 Provides-Extra: dev
 Requires-Dist: codecov; extra == "dev"
-Requires-Dist: flake8; extra == "dev"
-Requires-Dist: flake8-pyproject; extra == "dev"
-Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff>=0.9.0; extra == "dev"
 Requires-Dist: docformatter; extra == "dev"
-Requires-Dist: isort; extra == "dev"
-Requires-Dist: linecheck; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"

microdf_python-1.3.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+microdf/__init__.py,sha256=ldRvhE8t4cD7qlxQ5yLndMnWEUYpDw4m-jCDV_psXkY,319
+microdf/microdataframe.py,sha256=8r3Ajq71I3QDP_odegM2BS3RIg1Es1ATdWYkxiIcY4c,37265
+microdf/microseries.py,sha256=0jx-CJpWnRHe_vcNg1914Pkct9C5JcfDisFdu0sltR4,33392
+microdf/tests/conftest.py,sha256=u-EMyX1-u_nM-YO0RJYCzYHQDXxUI2WQE6GkyJlErqg,150
+microdf/tests/test_microseries_dataframe.py,sha256=h_GeIj9o_vgAauQhl7Nue0DPGXINq4HJRN2KceuQ-mw,30985
+microdf/tests/test_pandas3_compatibility.py,sha256=A34Ni_WQ303sSNv-sqv5CGAQp54zj-ZSGAPEBHZslNI,8573
+microdf_python-1.3.0.dist-info/licenses/LICENSE,sha256=uPs-ASYnzlldpf2z8jeRgQFeEH3FLhSuX0rw0OKWoDU,1067
+microdf_python-1.3.0.dist-info/METADATA,sha256=SIb647k9Jm3iMPVGgyAWWQE7xeZW1tI8OFFHrnOmFfc,2311
+microdf_python-1.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+microdf_python-1.3.0.dist-info/top_level.txt,sha256=T2WFPTygQQMdS3GF8YpZ12DKfMGrspbZ3r7z-e3KfiM,8
+microdf_python-1.3.0.dist-info/RECORD,,

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

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

microdf_python-1.2.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-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,,