microdf-python 1.3.0__tar.gz → 1.3.2__tar.gz

{microdf_python-1.3.0/microdf_python.egg-info → microdf_python-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.3.0
+Version: 1.3.2
 Summary: Weighted pandas DataFrames and Series for survey microdata
 Author-email: Max Ghenis <max@policyengine.org>
 License: MIT
@@ -50,13 +50,12 @@ import microdf as mdf
 import pandas as pd
 
 # Create sample data with weights
-df = pd.DataFrame({
-    'income': [10_000, 20_000, 30_000, 40_000, 50_000],
-    'weights': [1, 2, 3, 2, 1]
-})
+df = pd.DataFrame(
+    {"income": [10_000, 20_000, 30_000, 40_000, 50_000], "weights": [1, 2, 3, 2, 1]}
+)
 
 # Create a MicroDataFrame
-mdf_df = mdf.MicroDataFrame(df, weights='weights')
+mdf_df = mdf.MicroDataFrame(df, weights="weights")
 
 # All operations are weight-aware
 print(mdf_df.income.mean())  # Weighted mean

{microdf_python-1.3.0 → microdf_python-1.3.2}/README.md

@@ -29,13 +29,12 @@ import microdf as mdf
 import pandas as pd
 
 # Create sample data with weights
-df = pd.DataFrame({
-    'income': [10_000, 20_000, 30_000, 40_000, 50_000],
-    'weights': [1, 2, 3, 2, 1]
-})
+df = pd.DataFrame(
+    {"income": [10_000, 20_000, 30_000, 40_000, 50_000], "weights": [1, 2, 3, 2, 1]}
+)
 
 # Create a MicroDataFrame
-mdf_df = mdf.MicroDataFrame(df, weights='weights')
+mdf_df = mdf.MicroDataFrame(df, weights="weights")
 
 # All operations are weight-aware
 print(mdf_df.income.mean())  # Weighted mean

{microdf_python-1.3.0 → microdf_python-1.3.2}/microdf/microdataframe.py

@@ -96,8 +96,10 @@ class _MicroILocIndexer:
 
 class MicroDataFrame(pd.DataFrame):
     def __init__(self, *args, weights=None, **kwargs):
-        """A DataFrame-inheriting class for weighted microdata. Weights can be
-        provided at initialisation, or using set_weights or set_weight_col.
+        """A DataFrame-inheriting class for weighted microdata.
+
+        Weights can be provided at initialisation, or using set_weights or
+        set_weight_col.
 
         :param weights: Array of weights.
         :type weights: np.array
@@ -231,8 +233,9 @@ class MicroDataFrame(pd.DataFrame):
         return fn
 
     def get_args_as_micro_series(*kwarg_names: tuple) -> Callable:
-        """Decorator for auto-parsing column names into MicroSeries objects. If
-        given, kwarg_names limits arguments checked to keyword arguments
+        """Decorator for auto-parsing column names into MicroSeries objects.
+
+        If given, kwarg_names limits arguments checked to keyword arguments
         specified.
 
         :param arg_names: argument names to restrict to.
@@ -292,8 +295,10 @@ class MicroDataFrame(pd.DataFrame):
         weights: Union[np.ndarray, str],
         preserve_old: Optional[bool] = False,
     ) -> None:
-        """Sets the weights for the MicroDataFrame. If a string is received, it
-        will be assumed to be the column name of the weight column.
+        """Sets the weights for the MicroDataFrame.
+
+        If a string is received, it will be assumed to be the column name of
+        the weight column.
 
         :param weights: Array of weights.
         :param preserve_old: If True, keeps the old weights as a column when

{microdf_python-1.3.0 → microdf_python-1.3.2}/microdf/microseries.py

@@ -14,10 +14,10 @@ def _weighted_top_share(
 ) -> float:
     """Share of the sum held by the top ``top_x_pct`` of weight.
 
-    Sort by value ascending, cumulate the weight, pick the slice from
-    the top that covers exactly ``top_x_pct`` of total weight, and
-    distribute the tied-at-cutoff row proportionally so constant values
-    return exactly ``top_x_pct`` rather than 1.0.
+    Sort by value ascending, cumulate the weight, pick the slice from the top
+    that covers exactly ``top_x_pct`` of total weight, and distribute the tied-
+    at-cutoff row proportionally so constant values return exactly
+    ``top_x_pct`` rather than 1.0.
     """
     if top_x_pct <= 0:
         return 0.0
@@ -51,8 +51,9 @@ def _weighted_top_share(
 
 class MicroSeries(pd.Series):
     def __init__(self, *args, weights: np.array = None, **kwargs):
-        """A Series-inheriting class for weighted microdata. Weights can be
-        provided at initialisation, or using set_weights.
+        """A Series-inheriting class for weighted microdata.
+
+        Weights can be provided at initialisation, or using set_weights.
 
         :param weights: Array of weights.
         :type weights: np.array
@@ -275,9 +276,9 @@ class MicroSeries(pd.Series):
         """Pandas ``cov`` — **unweighted**.
 
         MicroSeries does not yet compute weighted covariance. Emits a
-        ``UserWarning`` so callers aren't silently given an unweighted
-        number after ``.sum()`` and ``.mean()`` worked as expected. See
-        issue tracker for a weighted implementation.
+        ``UserWarning`` so callers aren't silently given an unweighted number
+        after ``.sum()`` and ``.mean()`` worked as expected. See issue tracker
+        for a weighted implementation.
         """
         warnings.warn(
             "MicroSeries.cov() falls through to pandas and is "
@@ -293,8 +294,8 @@ class MicroSeries(pd.Series):
         """Pandas ``corr`` — **unweighted**.
 
         MicroSeries does not yet compute weighted correlation. Emits a
-        ``UserWarning`` so callers aren't silently given an unweighted
-        number. See issue tracker for a weighted implementation.
+        ``UserWarning`` so callers aren't silently given an unweighted number.
+        See issue tracker for a weighted implementation.
         """
         warnings.warn(
             "MicroSeries.corr() falls through to pandas and is "
@@ -519,13 +520,13 @@ class MicroSeries(pd.Series):
     def rank(self, pct: Optional[bool] = False) -> pd.Series:
         """Weighted rank of each element.
 
-        Each element's rank is the cumulative weight of all values that
-        are less than or equal to it. Tied values therefore share the
-        same rank, so downstream bucketing (``decile_rank``,
-        ``quintile_rank``, etc.) lands tied rows in the same bucket.
+        Each element's rank is the cumulative weight of all values that are
+        less than or equal to it. Tied values therefore share the same rank, so
+        downstream bucketing (``decile_rank``, ``quintile_rank``, etc.) lands
+        tied rows in the same bucket.
 
-        :param pct: If True, divide ranks by the total weight so they
-            lie in ``(0, 1]``.
+        :param pct: If True, divide ranks by the total weight so they lie in
+            ``(0, 1]``.
         :type pct: bool
         :returns: MicroSeries of ranks aligned to ``self``.
         :rtype: MicroSeries

{microdf_python-1.3.0 → microdf_python-1.3.2}/microdf/tests/test_microseries_dataframe.py

@@ -449,11 +449,11 @@ def test_mean_no_warning() -> None:
 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.
+    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])
@@ -541,10 +541,9 @@ 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)``.
+    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(
@@ -587,10 +586,10 @@ def test_merge_preserves_weights_per_surviving_row() -> None:
 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.
+    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)
@@ -616,11 +615,10 @@ def test_groupby_does_not_leak_tmp_weights_column() -> None:
 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.
+    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
@@ -681,10 +679,9 @@ def test_top_x_pct_share_handles_ties_and_edges() -> None:
 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.
+    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])
 
@@ -715,10 +712,9 @@ def test_gini_negatives_option_applied() -> None:
 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.
+    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.
@@ -751,8 +747,8 @@ def test_std_var_are_weighted() -> None:
 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.
+    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])
@@ -773,9 +769,9 @@ def test_cov_corr_warn_when_fallthrough() -> None:
 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.
+    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
@@ -794,12 +790,12 @@ def test_count_skips_nan_by_default() -> None:
 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.
+    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)

{microdf_python-1.3.0 → microdf_python-1.3.2/microdf_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.3.0
+Version: 1.3.2
 Summary: Weighted pandas DataFrames and Series for survey microdata
 Author-email: Max Ghenis <max@policyengine.org>
 License: MIT
@@ -50,13 +50,12 @@ import microdf as mdf
 import pandas as pd
 
 # Create sample data with weights
-df = pd.DataFrame({
-    'income': [10_000, 20_000, 30_000, 40_000, 50_000],
-    'weights': [1, 2, 3, 2, 1]
-})
+df = pd.DataFrame(
+    {"income": [10_000, 20_000, 30_000, 40_000, 50_000], "weights": [1, 2, 3, 2, 1]}
+)
 
 # Create a MicroDataFrame
-mdf_df = mdf.MicroDataFrame(df, weights='weights')
+mdf_df = mdf.MicroDataFrame(df, weights="weights")
 
 # All operations are weight-aware
 print(mdf_df.income.mean())  # Weighted mean

{microdf_python-1.3.0 → microdf_python-1.3.2}/pyproject.toml

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