microdf-python 0.4.4__py3-none-any.whl → 0.4.6__py3-none-any.whl

microdf/inequality.py

@@ -1,9 +1,18 @@
+from typing import List, Optional, Union
+
 import numpy as np
+import pandas as pd
 
 import microdf as mdf
 
 
-def gini(df, col, w=None, negatives=None, groupby=None):
+def gini(
+    df: pd.DataFrame,
+    col: str,
+    w: Optional[str] = None,
+    negatives: Optional[str] = None,
+    groupby: Optional[Union[str, List[str]]] = None,
+) -> float:
     """Calculates Gini index.
 
     :param df: DataFrame.
@@ -18,10 +27,14 @@ def gini(df, col, w=None, negatives=None, groupby=None):
         Defaults to None, which leaves negative values as they are.
     :param groupby: Column, or list of columns, to group by.
     :returns: A float, the Gini index.
-
     """
 
-    def _gini(df, col, w=None, negatives=None):
+    def _gini(
+        df: pd.DataFrame,
+        col: str,
+        w: Optional[str] = None,
+        negatives: Optional[str] = None,
+    ) -> float:
         # Requires float numpy arrays (not pandas Series or lists) to work.
         x = np.array(df[col]).astype("float")
         if negatives == "zero":
@@ -50,7 +63,13 @@ def gini(df, col, w=None, negatives=None, groupby=None):
     return df.groupby(groupby).apply(lambda x: _gini(x, col, w, negatives))
 
 
-def top_x_pct_share(df, col, top_x_pct, w=None, groupby=None):
+def top_x_pct_share(
+    df: pd.DataFrame,
+    col: str,
+    top_x_pct: float,
+    w: Optional[str] = None,
+    groupby: Optional[Union[str, List[str]]] = None,
+) -> float:
     """Calculates top x% share.
 
     :param df: DataFrame.
@@ -59,10 +78,11 @@ def top_x_pct_share(df, col, top_x_pct, w=None, groupby=None):
     :param w: Column representing weight in df.
     :param groupby: Column, or list of columns, to group by.
     :returns: The share of w-weighted val held by the top x%.
-
     """
 
-    def _top_x_pct_share(df, col, top_x_pct, w=None):
+    def _top_x_pct_share(
+        df: pd.DataFrame, col: str, top_x_pct: float, w: Optional[str] = None
+    ) -> float:
         threshold = mdf.weighted_quantile(df, col, w, 1 - top_x_pct)
         top_x_pct_sum = mdf.weighted_sum(df[df[col] >= threshold], col, w)
         total_sum = mdf.weighted_sum(df, col, w)
@@ -75,7 +95,13 @@ def top_x_pct_share(df, col, top_x_pct, w=None, groupby=None):
     )
 
 
-def bottom_x_pct_share(df, col, bottom_x_pct, w=None, groupby=None):
+def bottom_x_pct_share(
+    df: pd.DataFrame,
+    col: str,
+    bottom_x_pct: float,
+    w: Optional[str] = None,
+    groupby: Optional[Union[str, List[str]]] = None,
+) -> float:
     """Calculates bottom x% share.
 
     :param df: DataFrame.
@@ -84,12 +110,16 @@ def bottom_x_pct_share(df, col, bottom_x_pct, w=None, groupby=None):
     :param w: Column representing weight in df.
     :param groupby: Column, or list of columns, to group by.
     :returns: The share of w-weighted val held by the bottom x%.
-
     """
     return 1 - top_x_pct_share(df, col, 1 - bottom_x_pct, w, groupby)
 
 
-def bottom_50_pct_share(df, col, w=None, groupby=None):
+def bottom_50_pct_share(
+    df: pd.DataFrame,
+    col: str,
+    w: Optional[str] = None,
+    groupby: Optional[Union[str, List[str]]] = None,
+) -> float:
     """Calculates bottom 50% share.
 
     :param df: DataFrame.
@@ -97,12 +127,16 @@ def bottom_50_pct_share(df, col, w=None, groupby=None):
     :param w: Column representing weight in df.
     :param groupby: Column, or list of columns, to group by.
     :returns: The share of w-weighted val held by the bottom 50%.
-
     """
     return bottom_x_pct_share(df, col, 0.5, w, groupby)
 
 
-def top_50_pct_share(df, col, w=None, groupby=None):
+def top_50_pct_share(
+    df: pd.DataFrame,
+    col: str,
+    w: Optional[str] = None,
+    groupby: Optional[Union[str, List[str]]] = None,
+) -> float:
     """Calculates top 50% share.
 
     :param df: DataFrame.
@@ -110,12 +144,16 @@ def top_50_pct_share(df, col, w=None, groupby=None):
     :param w: Column representing weight in df.
     :param groupby: Column, or list of columns, to group by.
     :returns: The share of w-weighted val held by the top 50%.
-
     """
     return top_x_pct_share(df, col, 0.5, w, groupby)
 
 
-def top_10_pct_share(df, col, w=None, groupby=None):
+def top_10_pct_share(
+    df: pd.DataFrame,
+    col: str,
+    w: Optional[str] = None,
+    groupby: Optional[Union[str, List[str]]] = None,
+) -> float:
     """Calculates top 10% share.
 
     :param df: DataFrame.
@@ -123,12 +161,16 @@ def top_10_pct_share(df, col, w=None, groupby=None):
     :param w: Column representing weight in df.
     :param groupby: Column, or list of columns, to group by.
     :returns: The share of w-weighted val held by the top 10%.
-
     """
     return top_x_pct_share(df, col, 0.1, w, groupby)
 
 
-def top_1_pct_share(df, col, w=None, groupby=None):
+def top_1_pct_share(
+    df: pd.DataFrame,
+    col: str,
+    w: Optional[str] = None,
+    groupby: Optional[Union[str, List[str]]] = None,
+) -> float:
     """Calculates top 1% share.
 
     :param df: DataFrame.
@@ -136,12 +178,16 @@ def top_1_pct_share(df, col, w=None, groupby=None):
     :param w: Column representing weight in df.
     :param groupby: Column, or list of columns, to group by.
     :returns: The share of w-weighted val held by the top 1%.
-
     """
     return top_x_pct_share(df, col, 0.01, w, groupby)
 
 
-def top_0_1_pct_share(df, col, w=None, groupby=None):
+def top_0_1_pct_share(
+    df: pd.DataFrame,
+    col: str,
+    w: Optional[str] = None,
+    groupby: Optional[Union[str, List[str]]] = None,
+) -> float:
     """Calculates top 0.1% share.
 
     :param df: DataFrame.
@@ -149,21 +195,24 @@ def top_0_1_pct_share(df, col, w=None, groupby=None):
     :param w: Column representing weight in df.
     :param groupby: Column, or list of columns, to group by.
     :returns: The share of w-weighted val held by the top 0.1%.
-
     """
     return top_x_pct_share(df, col, 0.001, w, groupby)
 
 
-def t10_b50(df, col, w=None, groupby=None):
+def t10_b50(
+    df: pd.DataFrame,
+    col: str,
+    w: Optional[str] = None,
+    groupby: Optional[Union[str, List[str]]] = None,
+) -> float:
     """Calculates ratio between the top 10% and bottom 50% shares.
 
     :param df: DataFrame.
     :param col: Name of column in df representing value.
     :param w: Column representing weight in df.
     :param groupby: Column, or list of columns, to group by.
-    :returns: The share of w-weighted val held by the top 10% divided by
-        the share of w-weighted val held by the bottom 50%.
-
+    :returns: The share of w-weighted val held by the top 10% divided by the
+        share of w-weighted val held by the bottom 50%.
     """
     t10 = top_10_pct_share(df, col, w, groupby)
     b50 = bottom_50_pct_share(df, col, w, groupby)

microdf/io.py

@@ -1,14 +1,14 @@
 import io
 import zipfile
-import requests
+
 import pandas as pd
+import requests
 
 HEADER = {
-    "User-Agent":
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_5) " +
-    "AppleWebKit/537.36 (KHTML, like Gecko) " +
-    "Chrome/50.0.2661.102 Safari/537.36"
-    }
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_5) "
+    + "AppleWebKit/537.36 (KHTML, like Gecko) "
+    + "Chrome/50.0.2661.102 Safari/537.36"
+}
 
 
 def read_stata_zip(url: str, **kwargs) -> pd.DataFrame:
@@ -19,11 +19,9 @@ def read_stata_zip(url: str, **kwargs) -> pd.DataFrame:
     Pending native support in
     https://github.com/pandas-dev/pandas/issues/26599.
 
-    :param url: URL string of .zip file containing a single
-            .dta file.
-    :param **kwargs: Arguments passed to pandas.read_stata().
+    :param url: URL string of .zip file containing a single .dta file. :param
+        **kwargs: Arguments passed to pandas.read_stata().
     :returns: DataFrame.
-
     """
     r = requests.get(url, headers=HEADER)
     data = io.BytesIO(r.content)

microdf/poverty.py

@@ -2,15 +2,14 @@ import numpy as np
 import pandas as pd
 
 
-def fpl(people: int):
+def fpl(people: int) -> float:
     """Calculates the federal poverty guideline for a household of a certain
-       size.
+    size.
 
     :param XTOT: The number of people in the household.
-    :param people: returns: The federal poverty guideline for the contiguous
-      48 states.
+    :param people: returns: The federal poverty guideline for the contiguous 48
+        states.
     :returns: The federal poverty guideline for the contiguous 48 states.
-
     """
     return 7820 + 4320 * people
 
@@ -18,8 +17,8 @@ def fpl(people: int):
 def poverty_rate(
     df: pd.DataFrame, income: str, threshold: str, w: str = None
 ) -> float:
-    """Calculate poverty rate, i.e., the population share with income
-       below their poverty threshold.
+    """Calculate poverty rate, i.e., the population share with income below
+    their poverty threshold.
 
     :param df: DataFrame with income, threshold, and possibly weight columns
         for each person/household.
@@ -43,7 +42,7 @@ def deep_poverty_rate(
     df: pd.DataFrame, income: str, threshold: str, w: str = None
 ) -> float:
     """Calculate deep poverty rate, i.e., the population share with income
-       below half their poverty threshold.
+    below half their poverty threshold.
 
     :param df: DataFrame with income, threshold, and possibly weight columns
         for each person/household.
@@ -67,7 +66,7 @@ def poverty_gap(
     df: pd.DataFrame, income: str, threshold: str, w: str = None
 ) -> float:
     """Calculate poverty gap, i.e., the total gap between income and poverty
-       thresholds for all people in poverty.
+    thresholds for all people in poverty.
 
     :param df: DataFrame with income, threshold, and possibly weight columns
         for each household (data should represent households, not persons).
@@ -91,8 +90,8 @@ def squared_poverty_gap(
     df: pd.DataFrame, income: str, threshold: str, w: str = None
 ) -> float:
     """Calculate squared poverty gap, i.e., the total squared gap between
-       income and poverty thresholds for all people in poverty.
-       Also known as poverty severity index.
+    income and poverty thresholds for all people in poverty. Also known as
+    poverty severity index.
 
     :param df: DataFrame with income, threshold, and possibly weight columns
         for each household (data should represent households, not persons).
@@ -117,7 +116,7 @@ def deep_poverty_gap(
     df: pd.DataFrame, income: str, threshold: str, w: str = None
 ) -> float:
     """Calculate deep poverty gap, i.e., the total gap between income and
-       halved poverty thresholds for all people in deep poverty.
+    halved poverty thresholds for all people in deep poverty.
 
     :param df: DataFrame with income, threshold, and possibly weight columns
         for each household (data should represent households, not persons).

microdf/style.py

@@ -4,7 +4,7 @@ GRID_COLOR = "#eeeeee"  # Previously lighter #f5f5f5.
 DPI = 200
 
 
-def set_plot_style(dpi: int = DPI):
+def set_plot_style(dpi: int = DPI) -> None:
     """Set plot style.
 
     :param dpi: DPI for saving and displaying figures, defaults to microdf.DPI
@@ -12,14 +12,14 @@ def set_plot_style(dpi: int = DPI):
     :type dpi: int, optional
     """
     try:
-        import seaborn as sns
         import matplotlib as mpl
         import matplotlib.font_manager as fm
+        import seaborn as sns
     except ImportError:
         raise ImportError(
-            "The function you've called requires extra dependencies. " +
-            "Please install microdf with the 'charts' extra by running " +
-            "'pip install microdf[charts]'"
+            "The function you've called requires extra dependencies. "
+            + "Please install microdf with the 'charts' extra by running "
+            + "'pip install microdf[charts]'"
         )
 
     sns.set_style("white")

microdf/tax.py

@@ -1,16 +1,17 @@
+from typing import Optional
+
 import numpy as np
 import pandas as pd
 
 
-def mtr(val, brackets, rates):
-    """Calculates the marginal tax rate applied to a value depending on a
-    tax schedule.
+def mtr(val: pd.Series, brackets: pd.Series, rates: pd.Series) -> pd.Series:
+    """Calculates the marginal tax rate applied to a value depending on a tax
+    schedule.
 
     :param val: Value to assess tax on, e.g. wealth or income (list or Series).
     :param brackets: Left side of each bracket (list or Series).
     :param rates: Rate corresponding to each bracket.
     :returns: Series of the size of val representing the marginal tax rate.
-
     """
     df_tax = pd.DataFrame({"brackets": brackets, "rates": rates})
     df_tax["base_tax"] = (
@@ -24,30 +25,27 @@ def mtr(val, brackets, rates):
 
 
 def tax_from_mtrs(
-    val,
-    brackets,
-    rates,
-    avoidance_rate=0,
-    avoidance_elasticity=0,
-    avoidance_elasticity_flat=0,
-):
+    val: pd.Series,
+    brackets: pd.Series,
+    rates: pd.Series,
+    avoidance_rate: Optional[float] = 0,
+    avoidance_elasticity: Optional[float] = 0,
+    avoidance_elasticity_flat: Optional[float] = 0,
+) -> pd.Series:
     """Calculates tax liability based on a marginal tax rate schedule.
 
     :param val: Value to assess tax on, e.g. wealth or income (list or Series).
     :param brackets: Left side of each bracket (list or Series).
     :param rates: Rate corresponding to each bracket.
     :param avoidance_rate: Constant avoidance/evasion rate in percentage terms.
-                        Defaults to zero.
-    :param avoidance_elasticity: Avoidance/evasion elasticity.
-                              Response of log taxable value with respect
-                              to tax rate.
-                              Defaults to zero. Should be positive.
-    :param avoidance_elasticity_flat: Response of taxable value with respect
-                                   to tax rate.
-                                   Use avoidance_elasticity in most cases.
-                                   Defaults to zero. Should be positive.
+        Defaults to zero.
+    :param avoidance_elasticity: Avoidance/evasion elasticity. Response of log
+        taxable value with respect to tax rate. Defaults to zero. Should be
+        positive.
+    :param avoidance_elasticity_flat: Response of taxable value with respect to
+        tax rate. Use avoidance_elasticity in most cases. Defaults to zero.
+        Should be positive.
     :returns: Series of tax liabilities with the same size as val.
-
     """
     assert (
         avoidance_rate == 0

microdf/taxcalc.py

@@ -1,14 +1,20 @@
+from typing import Optional
+
+import pandas as pd
+import taxcalc
+
 import microdf as mdf
 from microdf._optional import import_optional_dependency
 
 
-def static_baseline_calc(recs, year):
+def static_baseline_calc(
+    recs: pd.DataFrame, year: int
+) -> "taxcalc.Calculator":
     """Creates a static Calculator object.
 
     :param recs: Records object.
     :param year: Year to advance to.
     :returns: Calculator object.
-
     """
     tc = import_optional_dependency("taxcalc")
     calc = tc.Calculator(records=recs, policy=tc.Policy())
@@ -17,7 +23,13 @@ def static_baseline_calc(recs, year):
     return calc
 
 
-def add_weighted_metrics(df, metric_vars, w="s006", divisor=1e6, suffix="_m"):
+def add_weighted_metrics(
+    df: pd.DataFrame,
+    metric_vars: list,
+    w: str = "s006",
+    divisor: float = 1e6,
+    suffix: str = "_m",
+) -> None:
     """Adds weighted metrics in millions to a Tax-Calculator pandas DataFrame.
 
     Columns are renamed to *_m.
@@ -27,10 +39,9 @@ def add_weighted_metrics(df, metric_vars, w="s006", divisor=1e6, suffix="_m"):
         name.
     :param w: Weight column. Defaults to s006.
     :param divisor: Number by which the product is divided. Defaults to 1e6.
-    :param suffix: Suffix to add to each weighted total. Defaults to '_m'
-            to match divisor default of 1e6.
+    :param suffix: Suffix to add to each weighted total. Defaults to '_m' to
+        match divisor default of 1e6.
     :returns: Nothing. Weighted columns are added in place.
-
     """
     df[w + suffix] = df[w] / divisor
     metric_vars = mdf.listify(metric_vars)
@@ -38,15 +49,16 @@ def add_weighted_metrics(df, metric_vars, w="s006", divisor=1e6, suffix="_m"):
         df[metric_var + suffix] = df[metric_var] * df[w + suffix]
 
 
-def n65(age_head, age_spouse, elderly_dependents):
+def n65(
+    age_head: pd.Series, age_spouse: pd.Series, elderly_dependents: pd.Series
+) -> pd.Series:
     """Calculates number of people in the tax unit age 65 or older.
 
     :param age_head: Series representing age_head from taxcalc data.
     :param age_spouse: Series representing age_spouse from taxcalc data.
     :param elderly_dependents: Series representing elderly_dependents from
-            taxcalc data.
+        taxcalc data.
     :returns: Series representing the number of people age 65 or older.
-
     """
     return (
         (age_head >= 65).astype(int)
@@ -56,14 +68,14 @@ def n65(age_head, age_spouse, elderly_dependents):
 
 
 def calc_df(
-    records=None,
-    policy=None,
-    year=2020,
-    reform=None,
-    group_vars=None,
-    metric_vars=None,
-    group_n65=False,
-):
+    records: Optional[pd.DataFrame] = None,
+    policy: Optional[taxcalc.Policy] = None,
+    year: int = 2020,
+    reform: Optional[dict] = None,
+    group_vars: Optional[list] = None,
+    metric_vars: Optional[list] = None,
+    group_n65: Optional[bool] = False,
+) -> pd.DataFrame:
     """Creates a pandas DataFrame for given Tax-Calculator data.
 
     s006 is always included, and RECID is used as an index.
@@ -71,19 +83,18 @@ def calc_df(
     :param records: An optional Records object. If not provided, uses CPS
         records. (Default value = None)
     :param policy: An optional Policy object. If not provided, uses default
-            Policy.
+        Policy.
     :param year: An optional year to advance to. If not provided, defaults to
-            2020.
+        2020.
     :param reform: An optional reform to implement for the Policy object.
         (Default value = None)
     :param group_vars: An optional list of column names to include in the
-            DataFrame. (Default value = None)
+        DataFrame. (Default value = None)
     :param metric_vars: An optional list of column names to include and
         calculate weighted sums of (in millions named as *_m) in the DataFrame.
         (Default value = None)
     :param group_n65: Whether to calculate and group by n65. Defaults to False.
     :returns: A pandas DataFrame. market_income is also always calculated.
-
     """
     tc = import_optional_dependency("taxcalc")
     # Assign defaults.
@@ -135,12 +146,11 @@ def calc_df(
     return df.set_index("RECID")
 
 
-def recalculate(df):
+def recalculate(df: pd.DataFrame) -> None:
     """Recalculates fields in the DataFrame for after components have changed.
 
     :param df: DataFrame for use in microdf.
     :returns: Nothing. Updates the DataFrame in place.
-
     """
     # Recalculate TPC's Expanded Cash Income measure.
     cols = df.columns

microdf/tests/conftest.py

@@ -0,0 +1,9 @@
+import os
+
+import pytest
+
+
+@pytest.fixture(scope="session")
+def tests_path() -> str:
+    """"""
+    return os.path.abspath(os.path.dirname(__file__))

microdf/tests/test_compare.py

@@ -0,0 +1,48 @@
+import os
+
+import numpy as np
+import pandas as pd
+
+import microdf as mdf
+
+
+def differences(
+    actual: pd.DataFrame,
+    expected: pd.DataFrame,
+    f_actual: str,
+    f_expected: str,
+) -> None:
+    """Check for differences between results in afilename and efilename files.
+
+    :param actual: Actual DataFrame.
+    :param expected: Expected DataFrame.
+    :param f_actual: Filename of the actual CSV.
+    :param f_expected: Filename of the expected CSV.
+    """
+    if not np.allclose(actual, expected):
+        msg = "COMPARE RESULTS DIFFER\n"
+        msg += "-------------------------------------------------\n"
+        msg += "--- NEW RESULTS IN {} FILE ---\n"
+        msg += "--- if new OK, copy {} to  ---\n"
+        msg += "---                 {}     ---\n"
+        msg += "---            and rerun test.                ---\n"
+        msg += "-------------------------------------------------\n"
+        raise ValueError(msg.format(f_actual, f_actual, f_expected))
+
+
+def test_percentile_agg_compare(tests_path: str) -> None:
+    """
+    :param tests_path: Folder path to write test results.
+    """
+    N = 1000
+    np.random.seed(0)
+    df = pd.DataFrame({"val": np.random.rand(N), "w": np.random.rand(N)})
+    mdf.add_weighted_quantiles(df, "val", "w")
+    percentile_sum = df.groupby("val_percentile")[["val", "w"]].sum()
+    F_ACTUAL = "test_percentile_actual.csv"
+    F_EXPECTED = "test_percentile_expected.csv"
+    percentile_sum.to_csv(os.path.join(tests_path, F_ACTUAL))
+    # Re-read as CSV to remove index and ensure CSVs are equal.
+    actual = pd.read_csv(os.path.join(tests_path, F_ACTUAL))
+    expected = pd.read_csv(os.path.join(tests_path, F_EXPECTED))
+    differences(actual, expected, F_ACTUAL, F_EXPECTED)

microdf/tests/test_decile_rank.py

@@ -0,0 +1,91 @@
+"""Test script for enhanced decile_rank functionality."""
+
+import numpy as np
+
+from microdf import MicroSeries
+
+
+def test_decile_rank() -> None:
+    """Test the enhanced decile_rank method with assert statements."""
+    print("Running enhanced decile_rank tests...")
+
+    # Create test data with some negative values
+    test_data = [-5, -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20]
+    test_weights = [1] * len(test_data)
+    test_ms = MicroSeries(test_data, weights=test_weights)
+
+    default_deciles = test_ms.decile_rank()
+    assert all(
+        1 <= d <= 10 for d in default_deciles.values
+    ), "Default deciles should be between 1 and 10"
+
+    negative_indices = [i for i, val in enumerate(test_data) if val < 0]
+    negative_deciles = [default_deciles.values[i] for i in negative_indices]
+    assert all(
+        d >= 1 for d in negative_deciles
+    ), "Negative values should be ranked 1-10 in default mode"
+
+    assert isinstance(
+        default_deciles, MicroSeries
+    ), "decile_rank should return MicroSeries"
+
+    zero_deciles = test_ms.decile_rank(negatives_in_zero=True)
+    negative_zero_deciles = [zero_deciles.values[i] for i in negative_indices]
+    assert all(
+        d == 0 for d in negative_zero_deciles
+    ), "Negative values should be in decile 0 when negatives_in_zero=True"
+
+    non_negative_indices = [i for i, val in enumerate(test_data) if val >= 0]
+    non_negative_deciles = [
+        zero_deciles.values[i] for i in non_negative_indices
+    ]
+    assert all(
+        1 <= d <= 10 for d in non_negative_deciles
+    ), "Non-negative values should be ranked 1-10 when negatives_in_zero=True"
+
+    unique_deciles = sorted(zero_deciles.unique())
+    assert 0 in unique_deciles, "Decile 0 should exist with negative values"
+    assert all(
+        d in unique_deciles for d in range(1, 11)
+    ), "Deciles 1-10 should exist with non-negative values"
+
+    positive_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    positive_ms = MicroSeries(positive_data, weights=[1] * 10)
+
+    pos_default = positive_ms.decile_rank()
+    pos_zero = positive_ms.decile_rank(negatives_in_zero=True)
+    assert np.array_equal(
+        pos_default.values, pos_zero.values
+    ), "Both modes should produce identical results for all positive data"
+    assert (
+        0 not in pos_zero.unique()
+    ), "Decile 0 should not exist when all values are positive"
+
+    negative_data = [-10, -8, -6, -4, -2]
+    negative_ms = MicroSeries(negative_data, weights=[1] * 5)
+
+    neg_default = negative_ms.decile_rank()
+    neg_zero = negative_ms.decile_rank(negatives_in_zero=True)
+    assert all(
+        1 <= d <= 10 for d in neg_default.values
+    ), "Default mode should rank all negative values 1-10"
+    assert all(
+        d == 0 for d in neg_zero.values
+    ), "All negative values should be in decile 0 when negatives_in_zero=True"
+
+    weighted_data = [-1, 0, 1, 2, 3]
+    weighted_weights = [0.5, 1.0, 1.5, 2.0, 2.5]
+    weighted_ms = MicroSeries(weighted_data, weights=weighted_weights)
+
+    w_default = weighted_ms.decile_rank()
+    w_zero = weighted_ms.decile_rank(negatives_in_zero=True)
+    assert np.array_equal(
+        w_default.weights.values, weighted_weights
+    ), "Weights should be preserved in default mode"
+    assert np.array_equal(
+        w_zero.weights.values, weighted_weights
+    ), "Weights should be preserved in negatives_in_zero mode"
+
+
+if __name__ == "__main__":
+    test_decile_rank()