microdf-python 1.2.1__tar.gz → 1.2.3__tar.gz

{microdf_python-1.2.1/microdf_python.egg-info → microdf_python-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.2.1
+Version: 1.2.3
 Summary: Weighted pandas DataFrames and Series for survey microdata
 Author-email: Max Ghenis <max@policyengine.org>
 License: MIT
@@ -11,15 +11,12 @@ 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"
+Requires-Dist: towncrier>=24.8.0; extra == "dev"
 Dynamic: license-file
 
 [![Build](https://github.com/PolicyEngine/microdf/workflows/Pull%20request/badge.svg)](https://github.com/PolicyEngine/microdf/actions)

{microdf_python-1.2.1 → microdf_python-1.2.3}/microdf/microdataframe.py

@@ -147,9 +147,7 @@ class MicroDataFrame(pd.DataFrame):
             for col in self.columns:
                 if pd.api.types.is_numeric_dtype(self[col]):
                     try:
-                        results[col] = getattr(self[col], name)(
-                            *args, **kwargs
-                        )
+                        results[col] = getattr(self[col], name)(*args, **kwargs)
                     except Exception:
                         # Skip columns that can't be aggregated
                         pass
@@ -224,9 +222,7 @@ class MicroDataFrame(pd.DataFrame):
                 for col in self.columns:
                     if pd.api.types.is_numeric_dtype(self[col]):
                         try:
-                            results[col] = getattr(self[col], name)(
-                                *args, **kwargs
-                            )
+                            results[col] = getattr(self[col], name)(*args, **kwargs)
                         except Exception:
                             # Skip columns that can't be aggregated
                             pass
@@ -323,9 +319,7 @@ class MicroDataFrame(pd.DataFrame):
                 self.weights = pd.Series(weights, dtype=float)
             self._link_all_weights()
 
-    def set_weight_col(
-        self, column: str, preserve_old: Optional[bool] = False
-    ) -> None:
+    def set_weight_col(self, column: str, preserve_old: Optional[bool] = False) -> None:
         """Sets the weights for the MicroDataFrame by specifying the name of
         the weight column.
 
@@ -594,9 +588,7 @@ class MicroDataFrame(pd.DataFrame):
         return equal_values and equal_weights
 
     @get_args_as_micro_series()
-    def groupby(
-        self, by: Union[str, List], *args, **kwargs
-    ) -> "MicroDataFrameGroupBy":
+    def groupby(self, by: Union[str, List], *args, **kwargs) -> "MicroDataFrameGroupBy":
         """Returns a GroupBy object with MicroSeriesGroupBy objects for each
         column.
 
@@ -757,14 +749,10 @@ class MicroDataFrameGroupBy(pd.core.groupby.generic.DataFrameGroupBy):
         self.columns.remove("__tmp_weights")
         # Filter to only numeric columns
         self.numeric_columns = [
-            col
-            for col in self.columns
-            if pd.api.types.is_numeric_dtype(self.obj[col])
+            col for col in self.columns if pd.api.types.is_numeric_dtype(self.obj[col])
         ]
         # Store reference to weights groupby for column selection
-        self._weights_groupby = copy.deepcopy(
-            super().__getitem__("__tmp_weights")
-        )
+        self._weights_groupby = copy.deepcopy(super().__getitem__("__tmp_weights"))
         for fn_name in MicroSeries.SCALAR_FUNCTIONS:
 
             def get_fn(name):
@@ -854,18 +842,14 @@ class MicroDataFrameGroupBy(pd.core.groupby.generic.DataFrameGroupBy):
                         results = {}
                         for col in res.numeric_columns:
                             try:
-                                results[col] = getattr(
-                                    getattr(res, col), name
-                                )(*args, **kwargs)
+                                results[col] = getattr(getattr(res, col), name)(
+                                    *args, **kwargs
+                                )
                             except Exception:
                                 pass
                         # Return plain DataFrame - aggregated results don't
                         # have per-row weights (weights were already applied)
-                        return (
-                            pd.DataFrame(results)
-                            if results
-                            else pd.DataFrame()
-                        )
+                        return pd.DataFrame(results) if results else pd.DataFrame()
 
                     return fn
 
@@ -877,18 +861,14 @@ class MicroDataFrameGroupBy(pd.core.groupby.generic.DataFrameGroupBy):
                         results = {}
                         for col in res.numeric_columns:
                             try:
-                                results[col] = getattr(
-                                    getattr(res, col), name
-                                )(*args, **kwargs)
+                                results[col] = getattr(getattr(res, col), name)(
+                                    *args, **kwargs
+                                )
                             except Exception:
                                 pass
                         # Return plain DataFrame - aggregated results don't
                         # have per-row weights (weights were already applied)
-                        return (
-                            pd.DataFrame(results)
-                            if results
-                            else pd.DataFrame()
-                        )
+                        return pd.DataFrame(results) if results else pd.DataFrame()
 
                     return fn
 

{microdf_python-1.2.1 → microdf_python-1.2.3}/microdf/microseries.py

@@ -1,4 +1,5 @@
 import logging
+import warnings
 from functools import wraps
 from typing import Callable, List, Optional, Union
 
@@ -19,6 +20,50 @@ class MicroSeries(pd.Series):
         super().__init__(*args, **kwargs)
         self.set_weights(weights)
 
+    @property
+    def _values(self):
+        """Internal access to underlying numpy array without warning."""
+        return super().values
+
+    @property
+    def values(self):
+        """Access underlying numpy array.
+
+        .. warning::
+            Returns a plain numpy array without weights. Operations
+            like ``.mean()`` on the result will be unweighted. Use
+            MicroSeries methods directly for weighted calculations
+            (e.g., ``ms.mean()`` instead of ``ms.values.mean()``).
+        """
+        warnings.warn(
+            "Accessing .values on a MicroSeries returns a plain numpy "
+            "array without weights. Operations like .mean() on the "
+            "result will be unweighted. Use MicroSeries methods "
+            "directly for weighted calculations (e.g., ms.mean() "
+            "instead of ms.values.mean()).",
+            UserWarning,
+            stacklevel=2,
+        )
+        return super().values
+
+    def to_numpy(self, *args, **kwargs):
+        """Convert to numpy array.
+
+        .. warning::
+            Returns a plain numpy array without weights. Operations
+            like ``.mean()`` on the result will be unweighted. Use
+            MicroSeries methods directly for weighted calculations.
+        """
+        warnings.warn(
+            "Calling .to_numpy() on a MicroSeries returns a plain "
+            "numpy array without weights. Operations like .mean() on "
+            "the result will be unweighted. Use MicroSeries methods "
+            "directly for weighted calculations.",
+            UserWarning,
+            stacklevel=2,
+        )
+        return super().to_numpy(*args, **kwargs)
+
     def weighted_function(fn: Callable) -> Callable:
         @wraps(fn)
         def safe_fn(*args, **kwargs):
@@ -51,9 +96,7 @@ class MicroSeries(pd.Series):
         """
         if weights is None:
             if len(self) > 0:
-                self.weights = pd.Series(
-                    np.ones_like(self.values), dtype=float
-                )
+                self.weights = pd.Series(np.ones_like(self._values), dtype=float)
         else:
             if len(weights) != len(self):
                 raise ValueError(
@@ -110,7 +153,7 @@ class MicroSeries(pd.Series):
         :returns: The weighted mean.
         :rtype: float
         """
-        values = self.values
+        values = self._values
         weights = self.weights
 
         if skipna:
@@ -141,12 +184,12 @@ class MicroSeries(pd.Series):
         :return: Weighted quantile value(s).
         :rtype: float or pd.Series
         """
-        values = np.array(self.values)
+        values = np.array(self._values)
         quantiles = np.atleast_1d(q)
         sample_weight = np.array(self.weights)
-        assert np.all(quantiles >= 0) and np.all(
-            quantiles <= 1
-        ), "quantiles should be in [0, 1]"
+        assert np.all(quantiles >= 0) and np.all(quantiles <= 1), (
+            "quantiles should be in [0, 1]"
+        )
         sorter = np.argsort(values)
         values = values[sorter]
         sample_weight = sample_weight[sorter]
@@ -154,11 +197,7 @@ class MicroSeries(pd.Series):
         cumsum_normalized = cumsum / cumsum[-1]
         result = np.array(
             [
-                values[
-                    min(
-                        np.searchsorted(cumsum_normalized, qi), len(values) - 1
-                    )
-                ]
+                values[min(np.searchsorted(cumsum_normalized, qi), len(values) - 1)]
                 for qi in quantiles
             ]
         )
@@ -313,7 +352,7 @@ class MicroSeries(pd.Series):
                 "in division by zero."
             )
 
-        order = np.argsort(self.values)
+        order = np.argsort(self._values)
         inverse_order = np.argsort(order)
         ranks = np.array(self.weights.values)[order].cumsum()[inverse_order]
         if pct:
@@ -409,9 +448,7 @@ class MicroSeries(pd.Series):
             return MicroSeries(res, weights=self.weights)
         return self
 
-    def round(
-        self, decimals: Optional[int] = 0, *args, **kwargs
-    ) -> "MicroSeries":
+    def round(self, decimals: Optional[int] = 0, *args, **kwargs) -> "MicroSeries":
         res = super().round(decimals=decimals, *args, **kwargs)
         return MicroSeries(res, weights=self.weights)
 
@@ -443,14 +480,10 @@ class MicroSeries(pd.Series):
     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":
+    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":
+    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":
@@ -480,14 +513,10 @@ class MicroSeries(pd.Series):
     def __rmul__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
         return MicroSeries(super().__rmul__(other), weights=self.weights)
 
-    def __rfloordiv__(
-        self, other: Union[int, float, pd.Series]
-    ) -> "MicroSeries":
+    def __rfloordiv__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
         return MicroSeries(super().__rfloordiv__(other), weights=self.weights)
 
-    def __rtruediv__(
-        self, other: Union[int, float, pd.Series]
-    ) -> "MicroSeries":
+    def __rtruediv__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
         return MicroSeries(super().__rtruediv__(other), weights=self.weights)
 
     def __rmod__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
@@ -506,7 +535,7 @@ class MicroSeries(pd.Series):
         return MicroSeries(super().__rxor__(other), weights=self.weights)
 
     def sqrt(self) -> "MicroSeries":
-        sqrt_values = np.sqrt(self.values)
+        sqrt_values = np.sqrt(self._values)
         return MicroSeries(sqrt_values, index=self.index, weights=self.weights)
 
     # comparators
@@ -540,17 +569,13 @@ class MicroSeries(pd.Series):
     def __imul__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
         return MicroSeries(super().__imul__(other), weights=self.weights)
 
-    def __ifloordiv__(
-        self, other: Union[int, float, pd.Series]
-    ) -> "MicroSeries":
+    def __ifloordiv__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
         return MicroSeries(super().__ifloordiv__(other), weights=self.weights)
 
     def __idiv__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
         return MicroSeries(super().__idiv__(other), weights=self.weights)
 
-    def __itruediv__(
-        self, other: Union[int, float, pd.Series]
-    ) -> "MicroSeries":
+    def __itruediv__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
         return MicroSeries(super().__itruediv__(other), weights=self.weights)
 
     def __imod__(self, other: Union[int, float, pd.Series]) -> "MicroSeries":
@@ -590,7 +615,7 @@ class MicroSeries(pd.Series):
 
     def __repr__(self) -> str:
         return pd.DataFrame(
-            dict(value=self.values, weight=self.weights.values)
+            dict(value=self._values, weight=self.weights.values)
         ).__repr__()
 
 
@@ -621,16 +646,12 @@ class MicroSeriesGroupBy(pd.core.groupby.generic.SeriesGroupBy):
     def _init(self):
         def _weighted_agg(name) -> Callable:
             def via_micro_series(row, *args, **kwargs):
-                return getattr(MicroSeries(row.a, weights=row.w), name)(
-                    *args, **kwargs
-                )
+                return getattr(MicroSeries(row.a, weights=row.w), name)(*args, **kwargs)
 
             fn = getattr(MicroSeries, name)
 
             @wraps(fn)
-            def _weighted_agg_fn(
-                *args, **kwargs
-            ) -> Union[pd.Series, pd.DataFrame]:
+            def _weighted_agg_fn(*args, **kwargs) -> Union[pd.Series, pd.DataFrame]:
                 arrays = self.apply(np.array)
                 weights = self.weights.apply(np.array)
                 df = pd.DataFrame(dict(a=arrays, w=weights))

{microdf_python-1.2.1 → microdf_python-1.2.3}/microdf/tests/test_microseries_dataframe.py

@@ -1,3 +1,5 @@
+import warnings
+
 import numpy as np
 import pandas as pd
 
@@ -259,9 +261,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
@@ -273,9 +273,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()
@@ -351,9 +349,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
@@ -371,9 +367,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]
@@ -381,9 +375,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
@@ -392,9 +384,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]
@@ -405,9 +395,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()
@@ -423,3 +411,45 @@ def test_groupby_column_selection() -> None:
     result_all = d.groupby("g").sum()
     assert "weight" not in result_all.columns
     assert list(result_all.columns) == ["y"]
+
+
+def test_values_warns() -> None:
+    """Accessing .values on a MicroSeries should emit a UserWarning."""
+    ms = mdf.MicroSeries([1, 2, 3], weights=[4, 5, 6])
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = ms.values
+        assert len(w) == 1
+        assert issubclass(w[0].category, UserWarning)
+        assert "weights" in str(w[0].message).lower()
+
+
+def test_to_numpy_warns() -> None:
+    """Calling .to_numpy() on a MicroSeries should emit a UserWarning."""
+    ms = mdf.MicroSeries([1, 2, 3], weights=[4, 5, 6])
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = ms.to_numpy()
+        assert len(w) == 1
+        assert issubclass(w[0].category, UserWarning)
+        assert "weights" in str(w[0].message).lower()
+
+
+def test_mean_no_warning() -> None:
+    """Internal .values usage in .mean() should NOT emit a warning."""
+    ms = mdf.MicroSeries([1, 2, 3], weights=[4, 5, 6])
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = ms.mean()
+        user_warnings = [x for x in w if issubclass(x.category, UserWarning)]
+        assert len(user_warnings) == 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])
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        _ = repr(ms)
+        user_warnings = [x for x in w if issubclass(x.category, UserWarning)]
+        assert len(user_warnings) == 0

{microdf_python-1.2.1 → microdf_python-1.2.3}/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.1 → microdf_python-1.2.3/microdf_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.2.1
+Version: 1.2.3
 Summary: Weighted pandas DataFrames and Series for survey microdata
 Author-email: Max Ghenis <max@policyengine.org>
 License: MIT
@@ -11,15 +11,12 @@ 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"
+Requires-Dist: towncrier>=24.8.0; extra == "dev"
 Dynamic: license-file
 
 [![Build](https://github.com/PolicyEngine/microdf/workflows/Pull%20request/badge.svg)](https://github.com/PolicyEngine/microdf/actions)

{microdf_python-1.2.1 → microdf_python-1.2.3}/microdf_python.egg-info/requires.txt

@@ -3,12 +3,9 @@ pandas
 
 [dev]
 codecov
-flake8
-flake8-pyproject
-black
+ruff>=0.9.0
 docformatter
-isort
-linecheck
 pytest
 pytest-cov
 setuptools
+towncrier>=24.8.0

{microdf_python-1.2.1 → microdf_python-1.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "microdf-python"
-version = "1.2.1"
+version = "1.2.3"
 description = "Weighted pandas DataFrames and Series for survey microdata"
 readme = "README.md"
 authors = [
@@ -20,15 +20,12 @@ dependencies = [
 [project.optional-dependencies]
 dev = [
     "codecov",
-    "flake8",
-    "flake8-pyproject",
-    "black",
+    "ruff>=0.9.0",
     "docformatter",
-    "isort",
-    "linecheck",
     "pytest",
     "pytest-cov",
     "setuptools",
+    "towncrier>=24.8.0",
 ]
 # Note: Documentation uses MyST (Jupyter Book 2.0) which is installed via npm
 # Run: cd docs && myst build --html
@@ -37,14 +34,35 @@ dev = [
 where = ["."]
 include = ["microdf*"]
 
-[tool.isort]
-profile = "black"
-line_length = 79
+[tool.towncrier]
+package = "microdf_python"
+directory = "changelog.d"
+filename = "CHANGELOG.md"
+title_format = "## [{version}] - {project_date}"
+issue_format = ""
+underlines = ["", "", ""]
 
-[tool.black]
-line-length = 79
-target-version = ["py313"]
+[[tool.towncrier.type]]
+directory = "breaking"
+name = "Breaking changes"
+showcontent = true
 
-[tool.flake8]
-max-line-length = 79
-extend-ignore = ["E203", "W503"]
+[[tool.towncrier.type]]
+directory = "added"
+name = "Added"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "changed"
+name = "Changed"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "fixed"
+name = "Fixed"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "removed"
+name = "Removed"
+showcontent = true