CLN: simplify Styler copy mechanics and tests (#42187)

Author: attack68

pandas/io/formats/style.py

@@ -964,39 +964,60 @@ def _update_ctx(self, attrs: DataFrame) -> None:
                 self.ctx[(i, j)].extend(css_list)
 
     def _copy(self, deepcopy: bool = False) -> Styler:
-        styler = Styler(
-            self.data,
-            precision=self.precision,
-            caption=self.caption,
-            table_attributes=self.table_attributes,
-            cell_ids=self.cell_ids,
-            na_rep=self.na_rep,
-        )
+        """
+        Copies a Styler, allowing for deepcopy or shallow copy
 
-        styler.uuid = self.uuid
-        styler.hide_index_ = self.hide_index_
+        Copying a Styler aims to recreate a new Styler object which contains the same
+        data and styles as the original.
 
-        if deepcopy:
-            styler.ctx = copy.deepcopy(self.ctx)
-            styler._todo = copy.deepcopy(self._todo)
-            styler.table_styles = copy.deepcopy(self.table_styles)
-            styler.hidden_columns = copy.copy(self.hidden_columns)
-            styler.cell_context = copy.deepcopy(self.cell_context)
-            styler.tooltips = copy.deepcopy(self.tooltips)
-        else:
-            styler.ctx = self.ctx
-            styler._todo = self._todo
-            styler.table_styles = self.table_styles
-            styler.hidden_columns = self.hidden_columns
-            styler.cell_context = self.cell_context
-            styler.tooltips = self.tooltips
+        Data dependent attributes [copied and NOT exported]:
+          - formatting (._display_funcs)
+          - hidden index values or column values (.hidden_rows, .hidden_columns)
+          - tooltips
+          - cell_context (cell css classes)
+          - ctx (cell css styles)
+          - caption
+
+        Non-data dependent attributes [copied and exported]:
+          - hidden index state and hidden columns state (.hide_index_, .hide_columns_)
+          - table_attributes
+          - table_styles
+          - applied styles (_todo)
+
+        """
+        # GH 40675
+        styler = Styler(
+            self.data,  # populates attributes 'data', 'columns', 'index' as shallow
+            uuid_len=self.uuid_len,
+        )
+        shallow = [  # simple string or boolean immutables
+            "hide_index_",
+            "hide_columns_",
+            "table_attributes",
+            "cell_ids",
+            "caption",
+        ]
+        deep = [  # nested lists or dicts
+            "_display_funcs",
+            "hidden_rows",
+            "hidden_columns",
+            "ctx",
+            "cell_context",
+            "_todo",
+            "table_styles",
+            "tooltips",
+        ]
+
+        for attr in shallow:
+            setattr(styler, attr, getattr(self, attr))
+
+        for attr in deep:
+            val = getattr(self, attr)
+            setattr(styler, attr, copy.deepcopy(val) if deepcopy else val)
 
         return styler
 
     def __copy__(self) -> Styler:
-        """
-        Deep copy by default.
-        """
         return self._copy(deepcopy=False)
 
     def __deepcopy__(self, memo) -> Styler:

pandas/tests/io/formats/style/test_style.py

@@ -38,6 +38,35 @@ def mi_styler(mi_df):
     return Styler(mi_df, uuid_len=0)
 
 
+@pytest.fixture
+def mi_styler_comp(mi_styler):
+    # comprehensively add features to mi_styler
+    mi_styler.uuid_len = 5
+    mi_styler.uuid = "abcde_"
+    mi_styler.set_caption("capt")
+    mi_styler.set_table_styles([{"selector": "a", "props": "a:v;"}])
+    mi_styler.hide_columns()
+    mi_styler.hide_columns([("c0", "c1_a")])
+    mi_styler.hide_index()
+    mi_styler.hide_index([("i0", "i1_a")])
+    mi_styler.set_table_attributes('class="box"')
+    mi_styler.format(na_rep="MISSING", precision=3)
+    mi_styler.highlight_max(axis=None)
+    mi_styler.set_td_classes(
+        DataFrame(
+            [["a", "b"], ["a", "c"]], index=mi_styler.index, columns=mi_styler.columns
+        )
+    )
+    mi_styler.set_tooltips(
+        DataFrame(
+            [["a2", "b2"], ["a2", "c2"]],
+            index=mi_styler.index,
+            columns=mi_styler.columns,
+        )
+    )
+    return mi_styler
+
+
 @pytest.mark.parametrize(
     "sparse_columns, exp_cols",
     [
@@ -156,6 +185,49 @@ def test_render_trimming_mi():
     assert {"attributes": 'colspan="2"'}.items() <= ctx["head"][0][2].items()
 
 
+@pytest.mark.parametrize("comprehensive", [True, False])
+@pytest.mark.parametrize("render", [True, False])
+@pytest.mark.parametrize("deepcopy", [True, False])
+def test_copy(comprehensive, render, deepcopy, mi_styler, mi_styler_comp):
+    styler = mi_styler_comp if comprehensive else mi_styler
+    styler.uuid_len = 5
+
+    s2 = copy.deepcopy(styler) if deepcopy else copy.copy(styler)  # make copy and check
+    assert s2 is not styler
+
+    if render:
+        styler.to_html()
+
+    excl = ["na_rep", "precision", "uuid", "cellstyle_map"]  # deprecated or special var
+    if not deepcopy:  # check memory locations are equal for all included attributes
+        for attr in [a for a in styler.__dict__ if (not callable(a) and a not in excl)]:
+            assert id(getattr(s2, attr)) == id(getattr(styler, attr))
+    else:  # check memory locations are different for nested or mutable vars
+        shallow = [
+            "data",
+            "columns",
+            "index",
+            "uuid_len",
+            "caption",
+            "cell_ids",
+            "hide_index_",
+            "hide_columns_",
+            "table_attributes",
+        ]
+        for attr in shallow:
+            assert id(getattr(s2, attr)) == id(getattr(styler, attr))
+
+        for attr in [
+            a
+            for a in styler.__dict__
+            if (not callable(a) and a not in excl and a not in shallow)
+        ]:
+            if getattr(s2, attr) is None:
+                assert id(getattr(s2, attr)) == id(getattr(styler, attr))
+            else:
+                assert id(getattr(s2, attr)) != id(getattr(styler, attr))
+
+
 class TestStyler:
     def setup_method(self, method):
         np.random.seed(24)
@@ -211,102 +283,6 @@ def test_update_ctx_flatten_multi_and_trailing_semi(self):
         }
         assert self.styler.ctx == expected
 
-    @pytest.mark.parametrize("do_changes", [True, False])
-    @pytest.mark.parametrize("do_render", [True, False])
-    def test_copy(self, do_changes, do_render):
-        # Updated in GH39708
-        # Change some defaults (to check later if the new values are copied)
-        if do_changes:
-            self.styler.set_table_styles(
-                [{"selector": "th", "props": [("foo", "bar")]}]
-            )
-            self.styler.set_table_attributes('class="foo" data-bar')
-            self.styler.hide_index_ = not self.styler.hide_index_
-            self.styler.hide_columns("A")
-            classes = DataFrame(
-                [["favorite-val red", ""], [None, "blue my-val"]],
-                index=self.df.index,
-                columns=self.df.columns,
-            )
-            self.styler.set_td_classes(classes)
-            ttips = DataFrame(
-                data=[["Favorite", ""], [np.nan, "my"]],
-                columns=self.df.columns,
-                index=self.df.index,
-            )
-            self.styler.set_tooltips(ttips)
-            self.styler.cell_ids = not self.styler.cell_ids
-
-        if do_render:
-            self.styler.render()
-
-        s_copy = copy.copy(self.styler)
-        s_deepcopy = copy.deepcopy(self.styler)
-
-        assert self.styler is not s_copy
-        assert self.styler is not s_deepcopy
-
-        # Check for identity
-        assert self.styler.ctx is s_copy.ctx
-        assert self.styler._todo is s_copy._todo
-        assert self.styler.table_styles is s_copy.table_styles
-        assert self.styler.hidden_columns is s_copy.hidden_columns
-        assert self.styler.cell_context is s_copy.cell_context
-        assert self.styler.tooltips is s_copy.tooltips
-        if do_changes:  # self.styler.tooltips is not None
-            assert self.styler.tooltips.tt_data is s_copy.tooltips.tt_data
-            assert (
-                self.styler.tooltips.class_properties
-                is s_copy.tooltips.class_properties
-            )
-            assert self.styler.tooltips.table_styles is s_copy.tooltips.table_styles
-
-        # Check for non-identity
-        assert self.styler.ctx is not s_deepcopy.ctx
-        assert self.styler._todo is not s_deepcopy._todo
-        assert self.styler.hidden_columns is not s_deepcopy.hidden_columns
-        assert self.styler.cell_context is not s_deepcopy.cell_context
-        if do_changes:  # self.styler.table_style is not None
-            assert self.styler.table_styles is not s_deepcopy.table_styles
-        if do_changes:  # self.styler.tooltips is not None
-            assert self.styler.tooltips is not s_deepcopy.tooltips
-            assert self.styler.tooltips.tt_data is not s_deepcopy.tooltips.tt_data
-            assert (
-                self.styler.tooltips.class_properties
-                is not s_deepcopy.tooltips.class_properties
-            )
-            assert (
-                self.styler.tooltips.table_styles
-                is not s_deepcopy.tooltips.table_styles
-            )
-
-        self.styler._update_ctx(self.attrs)
-        self.styler.highlight_max()
-        assert self.styler.ctx == s_copy.ctx
-        assert self.styler.ctx != s_deepcopy.ctx
-        assert self.styler._todo == s_copy._todo
-        assert self.styler._todo != s_deepcopy._todo
-        assert s_deepcopy._todo == []
-
-        equal_attributes = [
-            "table_styles",
-            "table_attributes",
-            "cell_ids",
-            "hide_index_",
-            "hidden_columns",
-            "cell_context",
-        ]
-        for s2 in [s_copy, s_deepcopy]:
-            for att in equal_attributes:
-                assert self.styler.__dict__[att] == s2.__dict__[att]
-            if do_changes:  # self.styler.tooltips is not None
-                tm.assert_frame_equal(self.styler.tooltips.tt_data, s2.tooltips.tt_data)
-                assert (
-                    self.styler.tooltips.class_properties
-                    == s2.tooltips.class_properties
-                )
-                assert self.styler.tooltips.table_styles == s2.tooltips.table_styles
-
     def test_clear(self):
         # updated in GH 39396
         tt = DataFrame({"A": [None, "tt"]})