Revert all functionality based around top level dataframe access

Let's not reinvent the wheel when accessing the final merged dataframe
with all the data. Give the user access to the dataframe and let them do
what they need from there.

Author: php1ic

src/nuclearmasses/mass_table.py

@@ -1,5 +1,4 @@
 import importlib.resources
-import typing
 
 import pandas as pd
 
@@ -13,48 +12,8 @@ class MassTable:
     Internally there are separate dataframes for the NUBASE and AME data as well as a combined one for all data
     """
 
-    def __init__(self, df: pd.DataFrame | None = None, filters: list[tuple[str, str, typing.Any]] | None = None):
-        self._original_df: pd.DataFrame = self._parse_files() if df is None else df
-        self._filters: list[tuple[str, str, typing.Any]] = filters or []
-        self._create_dynamic_getters()
-
-    def __repr__(self) -> str:
-        """Make printing the class object show the DataFrame nicely"""
-        return repr(self.df)
-
-    def __str__(self) -> str:
-        """Make printing the class object show the DataFrame nicely"""
-        return str(self.df)
-
-    def __getattr__(self, attr: str) -> typing.Any:
-        """Delegate pandas methods for deeper chaining"""
-        if hasattr(self.df, attr):
-            return getattr(self.df, attr)
-        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{attr}'")
-
-    def __dir__(self):
-        """Pass the pandas api through so we can get autocomplete"""
-        return sorted(set(list(self.__dict__.keys()) + dir(type(self)) + dir(self.df)))
-
-    # def __len__(self) -> int:
-    #     return len(self.df)
-    #
-    # def __iter__(self):
-    #     return iter(self.df)
-    #
-    def __getitem__(self, key):
-        return type(self)(df=self.df[key])
-
-    def get(self, column: str, value: typing.Any) -> typing.Self:
-        """Generic getter: all_data.get('A', 123)"""
-        new_filters = self._filters + [(column, "==", value)]
-        return type(self)(df=self._original_df, filters=new_filters)
-
-    def filter(self, expr: str) -> typing.Self:
-        """Allow arbitrary pandas .query() expressions."""
-        # For simplicity we still store as tuples; you could store raw expressions too
-        new_filters = self._filters + [("query", expr, None)]
-        return type(self)(df=self._original_df, filters=new_filters)
+    def __init__(self) -> None:
+        self._complete_df: pd.DataFrame = self._parse_files()
 
     def _parse_files(self) -> pd.DataFrame:
         data_path = importlib.resources.files("nuclearmasses").joinpath("data")
@@ -64,32 +23,6 @@ def _parse_files(self) -> pd.DataFrame:
         return pd.merge(AME(data_path).ame_df, NUBASE(data_path).nubase_df, on=common_columns, how="outer")
 
     @property
-    def df(self) -> pd.DataFrame:
-        """Apply all filters only when .df is accessed"""
-        result = self._original_df
-        for key, op, val in self._filters:
-            if op == "==":
-                # Filter on the index
-                if key == self._original_df.index.name:
-                    result = result[result.index == val]
-                # Filter on a regular column
-                else:
-                    result = result[result[key] == val]
-            elif key == "query":
-                result = result.query(op)
-        return result
-
-    def _create_dynamic_getters(self):
-        """Automatically create get_colname(value) methods for every column."""
-        for col in self._original_df.columns:
-            method_name = f"get_{col}"
-
-            def make_getter(column: str):
-                def getter(self, value: typing.Any) -> MassTable:
-                    new_filters = self._filters + [(column, "==", value)]
-                    return type(self)(df=self._original_df, filters=new_filters)
-
-                return getter
-
-            # Attach the method to the class/instance
-            setattr(self, method_name, make_getter(col).__get__(self, MassTable))
+    def data(self) -> pd.DataFrame:
+        """Access the complete mass table dataframe"""
+        return self._complete_df

tests/test_mass_table.py

@@ -1,157 +1,8 @@
-import pandas as pd
-import pandas.testing as pdt
-import pytest
-
 from nuclearmasses.mass_table import MassTable
 
 
-@pytest.fixture
-def empty_frame():
-    return MassTable(df=pd.DataFrame())
-
-
 def test_initial_complete_parse():
-    data = MassTable().df
+    data = MassTable().data
     expected_shape = (21421, 50)
 
     assert expected_shape == data.shape
-
-
-def test_getter_creation():
-    cols = ["Mass", "Error", "Param", "RandomLongerString"]
-    test_frame = pd.DataFrame.from_dict(data=dict.fromkeys(cols, [0]))
-
-    df = MassTable(df=test_frame)
-
-    for name in cols:
-        f = f"get_{name}"
-        assert hasattr(df, f)
-        assert callable(getattr(df, f))
-
-
-def test_getter_not_created(empty_frame):
-    with pytest.raises(AttributeError):
-        empty_frame.get_Nothing()
-
-
-def test_empty_filter(empty_frame):
-    assert len(empty_frame._filters) == 0
-
-
-def test_unique_and_sorted_dir(empty_frame):
-    output = dir(empty_frame)
-    assert output == sorted(output)
-    assert len(output) == len(set(output))
-
-
-def test_dir_includes_class_attributes(empty_frame):
-    output = dir(empty_frame)
-
-    assert "_parse_files" in output
-    assert "get" in output
-
-
-def test_dir_includes_pandas_attributes(empty_frame):
-    output = dir(empty_frame)
-
-    assert "describe" in output
-    assert "head" in output
-
-
-def test_manually_populated_filter():
-    cols = ["ManualParameter"]
-    test_frame = pd.DataFrame.from_dict(data=dict.fromkeys(cols, [0]))
-
-    my_filter = [(cols[0], "==", 5)]
-
-    df = MassTable(df=test_frame, filters=my_filter)
-
-    assert len(df._filters) == 1
-    assert df._filters == my_filter
-
-
-def test_auto_populated_filter():
-    cols = ["AutoParameter"]
-    test_frame = pd.DataFrame.from_dict(data=dict.fromkeys(cols, [0]))
-
-    df = MassTable(df=test_frame)
-
-    val = 2
-    f_df = df.get_AutoParameter(val)
-
-    assert len(f_df._filters) == 1
-    assert f_df._filters == [(cols[0], "==", val)]
-
-
-def test_getter_on_index():
-    cols = ["Mass", "Error", "Param", "RandomLongerString"]
-    test_frame = pd.DataFrame.from_dict(data=dict.fromkeys(cols, [0]))
-    test_frame.set_index("Param")
-
-    m_df = MassTable(df=test_frame)
-    m_df = m_df.get_Param(0).df
-
-    expected = pd.DataFrame(
-        {
-            "Mass": [0],
-            "Error": [0],
-            "Param": [0],
-            "RandomLongerString": [0],
-        }
-    )
-
-    pdt.assert_frame_equal(m_df, expected, check_like=True)
-
-
-def test_access_property():
-    cols = ["Mass", "Error", "Param", "RandomLongerString"]
-    test_frame = pd.DataFrame.from_dict(data=dict.fromkeys(cols, [0]))
-
-    m_df = MassTable(df=test_frame).df
-
-    expected = pd.DataFrame(
-        {
-            "Mass": [0],
-            "Error": [0],
-            "Param": [0],
-            "RandomLongerString": [0],
-        }
-    )
-
-    pdt.assert_frame_equal(m_df, expected, check_like=True)
-
-
-def test_generic_getter():
-    cols = ["Mass", "Error", "Param", "RandomLongerString"]
-    test_frame = pd.DataFrame.from_dict(data=dict.fromkeys(cols, [0]))
-
-    m_df = MassTable(df=test_frame).get("Error", 0).df
-
-    expected = pd.DataFrame(
-        {
-            "Mass": [0],
-            "Error": [0],
-            "Param": [0],
-            "RandomLongerString": [0],
-        }
-    )
-
-    pdt.assert_frame_equal(m_df, expected, check_like=True)
-
-
-def test_generic_filter():
-    cols = ["Mass", "Error", "Param", "RandomLongerString"]
-    test_frame = pd.DataFrame.from_dict(data=dict.fromkeys(cols, [0]))
-
-    m_df = MassTable(df=test_frame).filter("Param == 0").df
-
-    expected = pd.DataFrame(
-        {
-            "Mass": [0],
-            "Error": [0],
-            "Param": [0],
-            "RandomLongerString": [0],
-        }
-    )
-
-    pdt.assert_frame_equal(m_df, expected, check_like=True)