ENH: restructure code for no new functions, only keyword additions

Author: attack68

doc/source/user_guide/style.ipynb

@@ -835,19 +835,20 @@
     "We hope to collect some useful ones either in pandas, or preferable in a new package that [builds on top](#Extensibility) the tools here.\n",
     "\n",
     "`table_styles` can be used to add column and row based class descriptors. For large tables this can increase performance by avoiding repetitive individual css for each cell, and it can also simplify style construction in some cases.\n",
-    "`Styler.extend_column_styles` is a specific function to set styles to individual columns.\n",
+    "If `table_styles` is given as a dictionary each key should be a specified column or index value and this will map to specific class CSS selectors of the given column or row.\n",
     "\n",
-    "Note that `Styler.set_table_styles` will overwrite existing styles (including those column based) whilst the preferred `Styler.extend_table_styles` will add to the current items."
+    "Note that `Styler.set_table_styles` will overwrite existing styles but can be chained by setting the `overwrite` argument to `False`."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "outputs": [],
    "source": [
-    "html = html.extend_column_styles({\n",
-    "    'B': [dict(selector='', props=[('color', 'blue')])]\n",
-    "})\n",
+    "html = html.set_table_styles({\n",
+    "    'B': [dict(selector='', props=[('color', 'green')])],\n",
+    "    'C': [dict(selector='td', props=[('color', 'red')])], \n",
+    "    }, overwrite=False)\n",
     "html"
    ],
    "metadata": {

doc/source/whatsnew/v1.1.1.rst

@@ -54,8 +54,7 @@ Categorical
 Other enhancements
 ~~~~~~~~~~~~~~~~~~
 
-- :meth:`Styler.extend_table_styles` added the supplement `Styler.set_table_styles` (:issue:`35607`)
-- :meth:`Styler.extend_column_styles` to directly add class based CSS to specified DataFrame columns (:issue:`35607`)
+- :meth:`Styler.set_table_styles` now allows the direct styling of rows and columns and can be chained (:issue:`35607`)
 
 .. ---------------------------------------------------------------------------
 

pandas/io/formats/style.py

@@ -909,117 +909,84 @@ def set_caption(self, caption: str) -> "Styler":
         self.caption = caption
         return self
 
-    def set_table_styles(self, table_styles) -> "Styler":
+    def set_table_styles(self, table_styles, axis=0, overwrite=True) -> "Styler":
         """
         Set the table styles on a Styler.
 
         These are placed in a ``<style>`` tag before the generated HTML table.
 
-        Parameters
-        ----------
-        table_styles : list
-            Each individual table_style should be a dictionary with
-            ``selector`` and ``props`` keys. ``selector`` should be a CSS
-            selector that the style will be applied to (automatically
-            prefixed by the table's UUID) and ``props`` should be a list of
-            tuples with ``(attribute, value)``.
-
-        Returns
-        -------
-        self : Styler
-
-        Examples
-        --------
-        >>> df = pd.DataFrame(np.random.randn(10, 4))
-        >>> df.style.set_table_styles(
-        ...     [{'selector': 'tr:hover',
-        ...       'props': [('background-color', 'yellow')]}]
-        ... )
-        """
-        self.table_styles = table_styles
-        return self
-
-    def extend_table_styles(self, table_styles) -> "Styler":
-        """
-        Extend the existing table styles on a Styler.
-
-        These are placed in a ``<style>`` tag before the generated HTML table.
+        This function can be used to style the entire table, columns, rows or
+        specific HTML selectors.
 
         Parameters
         ----------
-        table_styles : list
-            Each individual table_style should be a dictionary with
-            ``selector`` and ``props`` keys. ``selector`` should be a CSS
-            selector that the style will be applied to (automatically
-            prefixed by the table's UUID) and ``props`` should be a list of
-            tuples with ``(attribute, value)``.
+        table_styles : list or dict
+            If supplying a list, each individual table_style should be a
+            dictionary with ``selector`` and ``props`` keys. ``selector``
+            should be a CSS selector that the style will be applied to
+            (automatically prefixed by the table's UUID) and ``props``
+            should be a list of tuples with ``(attribute, value)``.
+            If supplying a dict, the dict keys should correspond to
+            column names or index values, depending upon the specified
+            `axis` argument. These will be mapped to row or col CSS
+            selectors. MultiIndex values as dict keys should be
+            in their respective tuple form. The dict values should be
+            a list as specified in the form with CSS selectors and
+            props that will be applied to the specified row or column.
+        axis : {0 or 'index', 1 or 'columns', None}, default 0
+            Apply to each column (``axis=0`` or ``'index'``), to each row
+            (``axis=1`` or ``'columns'``). Only used if `table_styles` is
+            dict.
+        overwrite : boolean, default True
+            Styles are replaced if `True`, or extended if `False`. CSS
+            rules are preserved so most recent styles set will dominate
+            if selectors intersect.
 
         Returns
         -------
         self : Styler
 
         Examples
         --------
-        >>> df = pd.DataFrame(np.random.randn(10, 4))
+        >>> df = pd.DataFrame(np.random.randn(10, 4),
+        ...                   columns=['A', 'B', 'C', 'D'])
         >>> df.style.set_table_styles(
         ...     [{'selector': 'tr:hover',
         ...       'props': [('background-color', 'yellow')]}]
-        ... ).extend_table_styles(
-        ...     [{'selector': '.col2',
-        ...       'props': [('background-color', 'blue')]}]
-        ...)
-        """
-        if self.table_styles is None:
-            return self.set_table_styles(table_styles)
-        self.table_styles.extend(table_styles)
+        ... )
+        >>> df.style.set_table_styles({
+        ...     'A': [{'selector': '',
+        ...            'props': [('color', 'red')]}],
+        ...     'B': [{'selector': 'td',
+        ...            'props': [('color', 'blue')]}]
+        ... }, overwrite=False)
+        >>> df.style.set_table_styles({
+        ...     0: [{'selector': 'td:hover',
+        ...          'props': [('font-size', '25px')]}]
+        ... }, axis=1, overwrite=False)
+        """
+        if isinstance(table_styles, dict):
+            if axis == 0 or axis == 'index':
+                obj = self.data.columns
+                idf = '.col'
+            else:
+                obj = self.data.index
+                idf = '.row'
+
+            _styles = []
+            for key, styles in table_styles.items():
+                for s in styles:
+                    c = str(obj.get_loc(key))
+                    _styles.append(
+                        {"selector": s["selector"] + idf + c, "props": s["props"]}
+                    )
+            table_styles = _styles
+        if not overwrite and self.table_styles is not None:
+            self.table_styles.extend(table_styles)
+        else:
+            self.table_styles = table_styles
         return self
 
-    def extend_column_styles(self, column_styles) -> "Styler":
-        """
-        Sets class styles for each column on a Styler.
-
-        These are placed in a ``<style>`` tag before the generated HTML table.
-
-        Parameters
-        ----------
-        column_styles : dict
-            Each key of the dict should be a column header with the value
-            being a list of individual styles. Each style is a dictionary with
-            ``selector`` and ``props`` keys. ``selector`` should be a CSS
-            selector that the style will be applied to (automatically
-            prefixed by the table's UUID) and ``props`` should be a list of
-            tuples with ``(attribute, value)``.
-
-        Returns
-        -------
-        self : Styler
-
-        Notes
-        -----
-        Where the ``selector`` is an empty string or `None` the ``props`` will
-        be applied to the column class generically.
-
-        Examples
-        --------
-        >>> df = pd.DataFrame(np.random.randn(3, 2), columns=['a', 'b'])
-        >>> df.style.extend_column_styles({
-        ...        'a': [{'selector': '',
-        ...               'props': [('font-size', '20px')]},
-        ...              {'selector': 'td:hover',
-        ...               'props': [('color', 'pink')]}],
-        ...        'b': [{'selector': '',
-        ...               'props': [('font-size', '10px')]}]
-        ... })
-        """
-        _styles = []
-        for col, styles in column_styles.items():
-            for s in styles:
-                c = str(self.data.columns.get_loc(col))
-                _styles.append(
-                    {"selector": s["selector"] + ".col" + c, "props": s["props"]}
-                )
-        return self.extend_table_styles(_styles)
-
     def set_na_rep(self, na_rep: str) -> "Styler":
         """
         Set the missing data representation on a Styler.

pandas/tests/io/formats/test_style.py

@@ -1682,22 +1682,28 @@ def f(a, b, styler):
         result = styler.pipe((f, "styler"), a=1, b=2)
         assert result == (1, 2, styler)
 
-    def test_extending_table_styles(self):
+    def test_chaining_table_styles(self):
         df = pd.DataFrame(data=[[0, 1], [1, 2]], columns=["A", "B"])
         styler = df.style.set_table_styles(
             [{"selector": "", "props": [("background-color", "yellow")]}]
-        ).extend_table_styles(
-            [{"selector": ".col0", "props": [("background-color", "blue")]}]
+        ).set_table_styles(
+            [{"selector": ".col0", "props": [("background-color", "blue")]}],
+            overwrite=False
         )
         assert len(styler.table_styles) == 2
 
-    def test_column_styling(self):
+    def test_column_and_row_styling(self):
         df = pd.DataFrame(data=[[0, 1], [1, 2]], columns=["A", "B"])
         s = Styler(df, uuid="_")
-        s = s.extend_column_styles(
+        s = s.set_table_styles(
             {"A": [{"selector": "", "props": [("color", "blue")]}]}
         )
         assert "#T__ .col0 {\n          color: blue;\n    }" in s.render()
+        s = s.set_table_styles(
+            {0: [{"selector": "", "props": [("color", "blue")]}]},
+            axis=1
+        )
+        assert "#T__ .row0 {\n          color: blue;\n    }" in s.render()
 
 
 @td.skip_if_no_mpl