microdf-python 1.0.1__tar.gz → 1.1.0__tar.gz

{microdf_python-1.0.1/microdf_python.egg-info → microdf_python-1.1.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.0.1
+Version: 1.1.0
 Summary: Weighted pandas DataFrames and Series for survey microdata
-Author-email: Max Ghenis <max@ubicenter.org>
+Author-email: Max Ghenis <max@policyengine.org>
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -20,8 +20,6 @@ Requires-Dist: linecheck; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"
-Provides-Extra: docs
-Requires-Dist: jupyter_book; extra == "docs"
 Dynamic: license-file
 
 [![Build](https://github.com/PolicyEngine/microdf/workflows/Pull%20request/badge.svg)](https://github.com/PolicyEngine/microdf/actions)

{microdf_python-1.0.1 → microdf_python-1.1.0}/microdf/microdataframe.py

@@ -12,6 +12,80 @@ from microdf.microseries import MicroSeries, MicroSeriesGroupBy
 logger = logging.getLogger(__name__)
 
 
+class _MicroLocIndexer:
+    """Custom loc indexer that returns MicroDataFrame with proper weights."""
+
+    def __init__(self, mdf: "MicroDataFrame"):
+        self._mdf = mdf
+        # Get the parent's loc indexer
+        self._parent_loc = pd.DataFrame.loc.fget(mdf)
+
+    def __getitem__(self, key):
+        # Use the parent DataFrame's loc indexer
+        result = self._parent_loc[key]
+
+        if isinstance(result, pd.DataFrame):
+            # Get the filtered weights based on the result's index
+            new_weights = self._mdf.weights.reindex(result.index)
+            return MicroDataFrame(result, weights=new_weights)
+        elif isinstance(result, pd.Series):
+            # Single row or column selected
+            if result.name in self._mdf.columns:
+                # Column was selected - return MicroSeries with all weights
+                return MicroSeries(result, weights=self._mdf.weights)
+            else:
+                # Row was selected - return as-is (scalar values for each col)
+                return result
+        else:
+            # Scalar value
+            return result
+
+    def __setitem__(self, key, value):
+        self._parent_loc[key] = value
+        self._mdf._link_all_weights()
+
+
+class _MicroILocIndexer:
+    """Custom iloc indexer that returns MicroDataFrame with proper weights."""
+
+    def __init__(self, mdf: "MicroDataFrame"):
+        self._mdf = mdf
+        # Get the parent's iloc indexer
+        self._parent_iloc = pd.DataFrame.iloc.fget(mdf)
+
+    def __getitem__(self, key):
+        # Use the parent DataFrame's iloc indexer
+        result = self._parent_iloc[key]
+
+        if isinstance(result, pd.DataFrame):
+            # Get the filtered weights based on the result's index
+            new_weights = self._mdf.weights.iloc[
+                self._mdf.index.get_indexer(result.index)
+            ]
+            new_weights = pd.Series(new_weights.values, index=result.index)
+            return MicroDataFrame(result, weights=new_weights)
+        elif isinstance(result, pd.Series):
+            # Single row or column selected
+            if isinstance(key, tuple) and len(key) == 2:
+                # df.iloc[:, col_idx] - column selection
+                row_key = key[0]
+                if isinstance(row_key, slice) and row_key == slice(None):
+                    # All rows selected for a column
+                    return MicroSeries(result, weights=self._mdf.weights)
+            # Check if this is a column (result index matches mdf index)
+            if result.index.equals(self._mdf.index):
+                return MicroSeries(result, weights=self._mdf.weights)
+            # Row selection - return as-is
+            return result
+        else:
+            # Scalar value
+            return result
+
+    def __setitem__(self, key, value):
+        self._parent_iloc[key] = value
+        self._mdf._link_all_weights()
+
+
 class MicroDataFrame(pd.DataFrame):
     def __init__(self, *args, weights=None, **kwargs):
         """A DataFrame-inheriting class for weighted microdata. Weights can be
@@ -26,6 +100,23 @@ class MicroDataFrame(pd.DataFrame):
         self._link_all_weights()
         self.override_df_functions()
 
+    @property
+    def loc(self) -> _MicroLocIndexer:
+        """Label-based indexer that preserves MicroDataFrame type and weights.
+
+        :return: Custom loc indexer for MicroDataFrame
+        """
+        return _MicroLocIndexer(self)
+
+    @property
+    def iloc(self) -> _MicroILocIndexer:
+        """Integer-based indexer that preserves MicroDataFrame type and
+        weights.
+
+        :return: Custom iloc indexer for MicroDataFrame
+        """
+        return _MicroILocIndexer(self)
+
     def override_df_functions(self) -> None:
         """Override DataFrame functions to work with weighted operations."""
         for name in MicroSeries.FUNCTIONS:
@@ -44,14 +135,17 @@ class MicroDataFrame(pd.DataFrame):
         """
 
         def fn(*args, **kwargs) -> pd.Series:
-            results = pd.Series(
-                [
-                    getattr(self[col], name)(*args, **kwargs)
-                    for col in self.columns
-                ]
-            )
-            results.index = self.columns
-            return results
+            results = {}
+            for col in self.columns:
+                if pd.api.types.is_numeric_dtype(self[col]):
+                    try:
+                        results[col] = getattr(self[col], name)(
+                            *args, **kwargs
+                        )
+                    except Exception:
+                        # Skip columns that can't be aggregated
+                        pass
+            return pd.Series(results)
 
         return fn
 
@@ -63,14 +157,24 @@ class MicroDataFrame(pd.DataFrame):
         """
 
         def fn(*args, **kwargs) -> pd.DataFrame:
-            results = pd.DataFrame(
-                [
-                    getattr(self[col], name)(*args, **kwargs)
-                    for col in self.columns
-                ]
-            )
-            results.index = self.columns
-            return results
+            results = []
+            columns = []
+            for col in self.columns:
+                if pd.api.types.is_numeric_dtype(self[col]):
+                    try:
+                        result = getattr(self[col], name)(*args, **kwargs)
+                        results.append(result)
+                        columns.append(col)
+                    except Exception:
+                        # Skip columns that can't be aggregated
+                        pass
+
+            if results:
+                df = pd.DataFrame(results)
+                df.index = columns
+                return df
+            else:
+                return pd.DataFrame()
 
         return fn
 
@@ -88,24 +192,37 @@ class MicroDataFrame(pd.DataFrame):
 
             if is_array:
                 # Use vector function behavior
-                results = pd.DataFrame(
-                    [
-                        getattr(self[col], name)(*args, **kwargs)
-                        for col in self.columns
-                    ]
-                )
-                results.index = self.columns
-                return results
+                results = []
+                columns = []
+                for col in self.columns:
+                    if pd.api.types.is_numeric_dtype(self[col]):
+                        try:
+                            result = getattr(self[col], name)(*args, **kwargs)
+                            results.append(result)
+                            columns.append(col)
+                        except Exception:
+                            # Skip columns that can't be aggregated
+                            pass
+
+                if results:
+                    df = pd.DataFrame(results)
+                    df.index = columns
+                    return df
+                else:
+                    return pd.DataFrame()
             else:
                 # Use scalar function behavior
-                results = pd.Series(
-                    [
-                        getattr(self[col], name)(*args, **kwargs)
-                        for col in self.columns
-                    ]
-                )
-                results.index = self.columns
-                return results
+                results = {}
+                for col in self.columns:
+                    if pd.api.types.is_numeric_dtype(self[col]):
+                        try:
+                            results[col] = getattr(self[col], name)(
+                                *args, **kwargs
+                            )
+                        except Exception:
+                            # Skip columns that can't be aggregated
+                            pass
+                return pd.Series(results)
 
         return fn
 
@@ -185,6 +302,7 @@ class MicroDataFrame(pd.DataFrame):
         if isinstance(weights, str):
             self.weights_col = weights
             self.weights = pd.Series(self[weights], dtype=float)
+            self._link_all_weights()
         elif weights is not None:
             if len(weights) != len(self):
                 raise ValueError(
@@ -203,11 +321,24 @@ class MicroDataFrame(pd.DataFrame):
         """Sets the weights for the MicroDataFrame by specifying the name of
         the weight column.
 
-        :param weights: Array of weights.
+        .. deprecated:: 1.0.2
+            Use :meth:`set_weights` with a string argument instead.
+            This method will be removed in a future version.
+
+        :param column: Name of the column to use as weights.
         :param preserve_old: If True, keeps the old weights as a column when
             new weights are provided.
-        :type weights: np.array
+        :type column: str
         """
+        import warnings
+
+        warnings.warn(
+            "set_weight_col is deprecated and will be removed in a "
+            "future version. Use set_weights(column_name) instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
         if preserve_old and self.weights_col is not None:
             self["old_" + self.weights_col] = self.weights
 
@@ -215,6 +346,15 @@ class MicroDataFrame(pd.DataFrame):
         self.weights_col = column
         self._link_all_weights()
 
+    def nullify_weights(self) -> None:
+        """Set all weights to 1, effectively making the DataFrame unweighted.
+
+        This is useful for comparing weighted and unweighted statistics or when
+        you want to temporarily ignore weights.
+        """
+        self.weights = np.ones(len(self))
+        self._link_all_weights()
+
     def __getitem__(
         self, key: Union[str, List]
     ) -> Union[pd.Series, pd.DataFrame]:
@@ -303,6 +443,138 @@ class MicroDataFrame(pd.DataFrame):
         res = MicroDataFrame(res, weights=self.weights.copy(deep))
         return res
 
+    def drop(
+        self,
+        labels=None,
+        axis=0,
+        index=None,
+        columns=None,
+        level=None,
+        inplace=False,
+        errors="raise",
+    ):
+        """Drop specified labels from rows or columns.
+
+        This method supports all parameters of pandas DataFrame.drop(),
+        including the 'inplace' parameter.
+
+        :param labels: Index or column labels to drop.
+        :param axis: Whether to drop labels from the index (0 or 'index') or
+            columns (1 or 'columns').
+        :param index: Alternative to specifying axis (labels, axis=0 is
+            equivalent to index=labels).
+        :param columns: Alternative to specifying axis (labels, axis=1 is
+            equivalent to columns=labels).
+        :param level: For MultiIndex, level from which the labels will be
+            removed.
+        :param inplace: If False, return a copy. Otherwise, do operation
+            inplace and return None.
+        :param errors: If 'ignore', suppress error and only existing labels are
+            dropped.
+        :return: MicroDataFrame or None if inplace=True.
+        """
+        if inplace:
+            weights_backup = self.weights.copy()
+            # Perform in-place drop on the parent DataFrame
+            super().drop(
+                labels=labels,
+                axis=axis,
+                index=index,
+                columns=columns,
+                level=level,
+                inplace=True,
+                errors=errors,
+            )
+            self.weights = weights_backup
+            self._link_all_weights()
+            return None
+        else:
+            res = super().drop(
+                labels=labels,
+                axis=axis,
+                index=index,
+                columns=columns,
+                level=level,
+                inplace=False,
+                errors=errors,
+            )
+            return MicroDataFrame(res, weights=self.weights)
+
+    def merge(
+        self,
+        right,
+        how="inner",
+        on=None,
+        left_on=None,
+        right_on=None,
+        left_index=False,
+        right_index=False,
+        sort=False,
+        suffixes=("_x", "_y"),
+        copy=True,
+        indicator=False,
+        validate=None,
+    ):
+        """Merge DataFrame or named Series objects with a database-style join.
+
+        This method overrides pandas DataFrame.merge() to return a
+        MicroDataFrame.
+
+        :param right: Object to merge with.
+        :param how: Type of merge to be performed.
+        :param on: Column or index level names to join on.
+        :param left_on: Column or index level names to join on in the left
+            DataFrame.
+        :param right_on: Column or index level names to join on in the right
+            DataFrame.
+        :param left_index: Use the index from the left DataFrame as the join
+            key(s).
+        :param right_index: Use the index from the right DataFrame as the join
+            key(s).
+        :param sort: Sort the join keys lexicographically in the result
+            DataFrame.
+        :param suffixes: A length-2 sequence where each element is optionally a
+            string indicating the suffix to add to overlapping column names.
+        :param copy: If False, avoid copy if possible.
+        :param indicator: If True, adds a column to output DataFrame called
+            "_merge".
+        :param validate: If specified, checks if merge is of specified type.
+        :return: MicroDataFrame with merged data.
+        """
+        res = super().merge(
+            right,
+            how=how,
+            on=on,
+            left_on=left_on,
+            right_on=right_on,
+            left_index=left_index,
+            right_index=right_index,
+            sort=sort,
+            suffixes=suffixes,
+            copy=copy,
+            indicator=indicator,
+            validate=validate,
+        )
+
+        # For inner join, both dataframes must have the same weights on
+        # matching rows. For now, we'll use the left dataframe's weights.
+        # This is a simplification and may need more sophisticated handling
+        return MicroDataFrame(res, weights=self.weights)
+
+    def __getattr__(self, name):
+        """Allow accessing columns as attributes (e.g., df.column_name).
+
+        This enables more intuitive column access while preserving MicroSeries
+        functionality when accessing columns.
+
+        :param name: Attribute name to access
+        :return: MicroSeries if the attribute is a column, otherwise delegates
+            to parent
+        """
+        if name in self.columns:
+            return self[name]
+        return super().__getattr__(name)
+
     def equals(self, other: "MicroDataFrame") -> bool:
         equal_values = super().equals(other)
         equal_weights = self.weights.equals(other.weights)
@@ -462,6 +734,7 @@ class MicroDataFrame(pd.DataFrame):
 
 class MicroDataFrameGroupBy(pd.core.groupby.generic.DataFrameGroupBy):
     def _init(self, by: Union[str, List]):
+        self._by = by
         self.columns = list(self.obj.columns)
         if isinstance(by, list):
             for column in by:
@@ -469,18 +742,32 @@ class MicroDataFrameGroupBy(pd.core.groupby.generic.DataFrameGroupBy):
         elif isinstance(by, str):
             self.columns.remove(by)
         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])
+        ]
+        # Store reference to weights groupby for column selection
+        self._weights_groupby = copy.deepcopy(
+            super().__getitem__("__tmp_weights")
+        )
         for fn_name in MicroSeries.SCALAR_FUNCTIONS:
 
             def get_fn(name):
                 def fn(*args, **kwargs):
-                    return MicroDataFrame(
-                        {
-                            col: getattr(getattr(self, col), name)(
+                    results = {}
+                    for col in self.numeric_columns:
+                        try:
+                            results[col] = getattr(getattr(self, col), name)(
                                 *args, **kwargs
                             )
-                            for col in self.columns
-                        }
-                    )
+                        except Exception:
+                            # Skip columns that can't be aggregated
+                            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 fn
 
@@ -489,15 +776,108 @@ class MicroDataFrameGroupBy(pd.core.groupby.generic.DataFrameGroupBy):
 
             def get_fn(name) -> Callable:
                 def fn(*args, **kwargs) -> Union[pd.Series, pd.DataFrame]:
-                    return MicroDataFrame(
-                        {
-                            col: getattr(getattr(self, col), name)(
+                    results = {}
+                    for col in self.numeric_columns:
+                        try:
+                            results[col] = getattr(getattr(self, col), name)(
                                 *args, **kwargs
                             )
-                            for col in self.columns
-                        }
-                    )
+                        except Exception:
+                            # Skip columns that can't be aggregated
+                            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 fn
 
             setattr(self, fn_name, get_fn(fn_name))
+
+    def __getitem__(
+        self, key: Union[str, List]
+    ) -> Union["MicroSeriesGroupBy", "MicroDataFrameGroupBy"]:
+        """Select columns from the groupby object while preserving weights.
+
+        This ensures that operations like groupby(col)["y"].sum() or
+        groupby(col)[["y"]].sum() use weighted aggregation.
+
+        :param key: Column name or list of column names
+        :return: MicroSeriesGroupBy for single column, MicroDataFrameGroupBy
+            for multiple columns
+        """
+        if isinstance(key, str):
+            # Single column - return MicroSeriesGroupBy
+            result = super().__getitem__(key)
+            result.__class__ = MicroSeriesGroupBy
+            result._init()
+            result.weights = self._weights_groupby
+            return result
+        else:
+            # Multiple columns - return a new MicroDataFrameGroupBy
+            # with only the selected columns
+            result = super().__getitem__(key)
+            result.__class__ = MicroDataFrameGroupBy
+            # Re-initialize with the subset of columns
+            result._by = self._by
+            result.columns = list(key) if hasattr(key, "__iter__") else [key]
+            result.numeric_columns = [
+                col
+                for col in result.columns
+                if pd.api.types.is_numeric_dtype(result.obj[col])
+            ]
+            result._weights_groupby = self._weights_groupby
+            # Set up the column attributes as MicroSeriesGroupBy
+            for col in result.columns:
+                col_gb = super().__getitem__(col)
+                col_gb.__class__ = MicroSeriesGroupBy
+                col_gb._init()
+                col_gb.weights = self._weights_groupby
+                setattr(result, col, col_gb)
+            # Set up the scalar and vector functions
+            for fn_name in MicroSeries.SCALAR_FUNCTIONS:
+
+                def get_scalar_fn(name, res):
+                    def fn(*args, **kwargs):
+                        results = {}
+                        for col in res.numeric_columns:
+                            try:
+                                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 fn
+
+                setattr(result, fn_name, get_scalar_fn(fn_name, result))
+            for fn_name in MicroSeries.VECTOR_FUNCTIONS:
+
+                def get_vector_fn(name, res):
+                    def fn(*args, **kwargs):
+                        results = {}
+                        for col in res.numeric_columns:
+                            try:
+                                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 fn
+
+                setattr(result, fn_name, get_vector_fn(fn_name, result))
+            return result

{microdf_python-1.0.1 → microdf_python-1.1.0}/microdf/microseries.py

@@ -66,6 +66,14 @@ class MicroSeries(pd.Series):
 
             self.weights = pd.Series(weights, dtype=float)
 
+    def nullify_weights(self) -> None:
+        """Set all weights to 1, effectively making the Series unweighted.
+
+        This is useful for comparing weighted and unweighted statistics or when
+        you want to temporarily ignore weights.
+        """
+        self.weights = pd.Series(np.ones(len(self)), dtype=float)
+
     @vector_function
     def weight(self) -> pd.Series:
         """Calculates the weighted value of the MicroSeries.

{microdf_python-1.0.1 → microdf_python-1.1.0}/microdf/tests/test_microseries_dataframe.py

@@ -23,6 +23,14 @@ def test_df_init() -> None:
     df.set_weight_col("w")
     assert df.a.mean() == np.average(arr, weights=w)
 
+    # Test set_weights with string (column name)
+    df2 = mdf.MicroDataFrame()
+    df2["a"] = arr
+    df2["w"] = w
+    df2.set_weights("w")  # Using string column name instead of set_weight_col
+    assert df2.a.mean() == np.average(arr, weights=w)
+    assert np.array_equal(df2.weights.values, w)
+
 
 def test_handles_empty_index() -> None:
     arr = np.array([0, 1, 1])
@@ -279,3 +287,60 @@ def test_reset_index_inplace() -> None:
     assert "second" in mdf_multi.columns
     assert list(mdf_multi.index) == [0, 1, 2, 3]
     np.testing.assert_array_equal(mdf_multi.weights.values, weights)
+
+
+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]
+    )
+
+    # Filter all rows (should get same weights)
+    filtered = df.loc[df.one == 1]
+    assert isinstance(filtered, MicroDataFrame)
+    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]
+    )
+    subset = df2.loc[df2.x > 2]
+    assert isinstance(subset, MicroDataFrame)
+    assert subset.x.sum() == 500.0  # 3*30 + 4*40 + 5*50 = 500
+    np.testing.assert_array_equal(subset.weights.values, [30.0, 40.0, 50.0])
+
+
+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]
+    )
+
+    # Select rows by position
+    subset = df.iloc[2:5]
+    assert isinstance(subset, MicroDataFrame)
+    assert subset.x.sum() == 500.0  # 3*30 + 4*40 + 5*50 = 500
+    np.testing.assert_array_equal(subset.weights.values, [30.0, 40.0, 50.0])
+
+
+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]
+    )
+
+    # Test single column string selection
+    result_str = d.groupby("g")["y"].sum()
+    assert result_str["a"] == 14.0  # 1*4 + 2*5 = 14
+    assert result_str["b"] == 18.0  # 3*6 = 18
+
+    # Test list column selection
+    result_list = d.groupby("g")[["y"]].sum()
+    assert result_list.loc["a", "y"] == 14.0
+    assert result_list.loc["b", "y"] == 18.0
+
+    # Aggregated results should be plain DataFrame (no spurious weight column)
+    result_all = d.groupby("g").sum()
+    assert "weight" not in result_all.columns
+    assert list(result_all.columns) == ["y"]

{microdf_python-1.0.1 → microdf_python-1.1.0/microdf_python.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: microdf-python
-Version: 1.0.1
+Version: 1.1.0
 Summary: Weighted pandas DataFrames and Series for survey microdata
-Author-email: Max Ghenis <max@ubicenter.org>
+Author-email: Max Ghenis <max@policyengine.org>
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -20,8 +20,6 @@ Requires-Dist: linecheck; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"
-Provides-Extra: docs
-Requires-Dist: jupyter_book; extra == "docs"
 Dynamic: license-file
 
 [![Build](https://github.com/PolicyEngine/microdf/workflows/Pull%20request/badge.svg)](https://github.com/PolicyEngine/microdf/actions)

{microdf_python-1.0.1 → microdf_python-1.1.0}/microdf_python.egg-info/requires.txt

@@ -12,6 +12,3 @@ linecheck
 pytest
 pytest-cov
 setuptools
-
-[docs]
-jupyter_book

{microdf_python-1.0.1 → microdf_python-1.1.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "microdf-python"
-version = "1.0.1"
+version = "1.1.0"
 description = "Weighted pandas DataFrames and Series for survey microdata"
 readme = "README.md"
 authors = [
-    { name = "Max Ghenis", email = "max@ubicenter.org" }
+    { name = "Max Ghenis", email = "max@policyengine.org" }
 ]
 license = { text = "MIT" }
 requires-python = ">=3.9"
@@ -30,9 +30,8 @@ dev = [
     "pytest-cov",
     "setuptools",
 ]
-docs = [
-    "jupyter_book",
-]
+# Note: Documentation uses MyST (Jupyter Book 2.0) which is installed via npm
+# Run: cd docs && myst build --html
 
 [tool.setuptools.packages.find]
 where = ["."]