ENH 14194: add style option for hiding index and columns

Author: nchmura4

pandas/io/formats/style.py

@@ -69,6 +69,9 @@ class Styler(object):
         a unique identifier to avoid CSS collisons; generated automatically
     caption: str, default None
         caption to attach to the table
+    index_hidden: bool, default False
+        hides the index in the html output
+        .. versionadded:: 0.20.1
 
     Attributes
     ----------
@@ -117,7 +120,8 @@ class Styler(object):
     template = env.get_template("html.tpl")
 
     def __init__(self, data, precision=None, table_styles=None, uuid=None,
-                 caption=None, table_attributes=None):
+                 caption=None, table_attributes=None, index_hidden=False,
+                 hidden_cols=None):
         self.ctx = defaultdict(list)
         self._todo = []
 
@@ -139,6 +143,11 @@ def __init__(self, data, precision=None, table_styles=None, uuid=None,
             precision = get_option('display.precision')
         self.precision = precision
         self.table_attributes = table_attributes
+        self.index_hidden = index_hidden
+        if hidden_cols is None:
+            hidden_cols = []
+        self.hidden_cols = hidden_cols
+
         # display_funcs maps (row, col) -> formatting function
 
         def default_display_func(x):
@@ -186,6 +195,8 @@ def _translate(self):
         caption = self.caption
         ctx = self.ctx
         precision = self.precision
+        index_hidden = self.index_hidden
+        hidden_cols = self.hidden_cols
         uuid = self.uuid or str(uuid1()).replace("-", "_")
         ROW_HEADING_CLASS = "row_heading"
         COL_HEADING_CLASS = "col_heading"
@@ -200,7 +211,7 @@ def format_attr(pair):
 
         # for sparsifying a MultiIndex
         idx_lengths = _get_level_lengths(self.index)
-        col_lengths = _get_level_lengths(self.columns)
+        col_lengths = _get_level_lengths(self.columns, hidden_cols)
 
         cell_context = dict()
 
@@ -223,7 +234,7 @@ def format_attr(pair):
             row_es = [{"type": "th",
                        "value": BLANK_VALUE,
                        "display_value": BLANK_VALUE,
-                       "is_visible": True,
+                       "is_visible": (not index_hidden),
                        "class": " ".join([BLANK_CLASS])}] * (n_rlvls - 1)
 
             # ... except maybe the last for columns.names
@@ -235,7 +246,7 @@ def format_attr(pair):
                            "value": name,
                            "display_value": name,
                            "class": " ".join(cs),
-                           "is_visible": True})
+                           "is_visible": (not index_hidden)})
 
             for c, value in enumerate(clabels[r]):
                 cs = [COL_HEADING_CLASS, "level%s" % r, "col%s" % c]
@@ -256,8 +267,8 @@ def format_attr(pair):
                 row_es.append(es)
             head.append(row_es)
 
-        if self.data.index.names and not all(x is None
-                                             for x in self.data.index.names):
+        if self.data.index.names and not index_hidden\
+           and not all(x is None for x in self.data.index.names):
             index_header_row = []
 
             for c, name in enumerate(self.data.index.names):
@@ -271,7 +282,7 @@ def format_attr(pair):
                 [{"type": "th",
                   "value": BLANK_VALUE,
                   "class": " ".join([BLANK_CLASS])
-                  }] * len(clabels[0]))
+                  }] * (len(clabels[0]) - len(hidden_cols)))
 
             head.append(index_header_row)
 
@@ -281,7 +292,8 @@ def format_attr(pair):
             for c, value in enumerate(rlabels[r]):
                 es = {
                     "type": "th",
-                    "is_visible": _is_visible(r, c, idx_lengths),
+                    "is_visible": (_is_visible(r, c, idx_lengths) &
+                                   (~index_hidden)),
                     "value": value,
                     "display_value": value,
                     "class": " ".join([ROW_HEADING_CLASS, "level%s" % c,
@@ -304,7 +316,8 @@ def format_attr(pair):
                     "value": value,
                     "class": " ".join(cs),
                     "id": "_".join(cs[1:]),
-                    "display_value": formatter(value)
+                    "display_value": formatter(value),
+                    "is_visible": (c not in hidden_cols)
                 })
                 props = []
                 for x in ctx[r, c]:
@@ -460,7 +473,9 @@ def _update_ctx(self, attrs):
     def _copy(self, deepcopy=False):
         styler = Styler(self.data, precision=self.precision,
                         caption=self.caption, uuid=self.uuid,
-                        table_styles=self.table_styles)
+                        table_styles=self.table_styles,
+                        index_hidden=self.index_hidden,
+                        hidden_cols=self.hidden_cols)
         if deepcopy:
             styler.ctx = copy.deepcopy(self.ctx)
             styler._todo = copy.deepcopy(self._todo)
@@ -716,7 +731,7 @@ def set_uuid(self, uuid):
 
     def set_caption(self, caption):
         """
-        Se the caption on a Styler
+        Set the caption on a Styler
 
         .. versionadded:: 0.17.1
 
@@ -762,6 +777,41 @@ def set_table_styles(self, table_styles):
         self.table_styles = table_styles
         return self
 
+    def hide_index(self):
+        """
+        Hide any indices from rendering.
+
+        .. versionadded:: 0.20.1
+
+        Returns
+        -------
+        self : Styler
+        """
+        self.index_hidden = True
+        return self
+
+    def hide_columns(self, subset):
+        """
+        Hide columns from rendering.
+
+        .. versionadded:: 0.20.1
+
+        Parameters
+        ----------
+
+        subset: IndexSlice
+            An argument to ``DataFrame.loc`` that identifies which columns
+            are hidden.
+
+        Returns
+        -------
+        self : Styler
+        """
+        subset = _non_reducing_slice(subset)
+        hidden_df = self.data.loc[subset]
+        self.hidden_cols = self.columns.get_indexer_for(hidden_df.columns)
+        return self
+
     # -----------------------------------------------------------------------
     # A collection of "builtin" styles
     # -----------------------------------------------------------------------
@@ -1009,31 +1059,48 @@ def _is_visible(idx_row, idx_col, lengths):
     return (idx_col, idx_row) in lengths
 
 
-def _get_level_lengths(index):
+def _get_level_lengths(index, hidden_elements=None):
     """
     Given an index, find the level lenght for each element.
+    Optional argument is a list of index positions which
+    should not be visible.
 
     Result is a dictionary of (level, inital_position): span
     """
     sentinel = com.sentinel_factory()
     levels = index.format(sparsify=sentinel, adjoin=False, names=False)
 
-    if index.nlevels == 1:
-        return {(0, i): 1 for i, value in enumerate(levels)}
+    if hidden_elements is None:
+        hidden_elements = []
 
     lengths = {}
+    if index.nlevels == 1:
+        for i, value in enumerate(levels):
+            if(i not in hidden_elements):
+                lengths[(0, i)] = 1
+        return lengths
 
     for i, lvl in enumerate(levels):
         for j, row in enumerate(lvl):
             if not get_option('display.multi_sparse'):
                 lengths[(i, j)] = 1
-            elif row != sentinel:
+            elif (row != sentinel) and (j not in hidden_elements):
                 last_label = j
                 lengths[(i, last_label)] = 1
-            else:
+            elif (row != sentinel):
+                # even if its hidden, keep track of it in case
+                # length >1 and later elemens are visible
+                last_label = j
+                lengths[(i, last_label)] = 0
+            elif(j not in hidden_elements):
                 lengths[(i, last_label)] += 1
 
-    return lengths
+    non_zero_lengths = {}
+    for element, length in lengths.items():
+        if(length >= 1):
+            non_zero_lengths[element] = length
+
+    return non_zero_lengths
 
 
 def _maybe_wrap_formatter(formatter):

pandas/tests/io/formats/test_style.py

@@ -702,6 +702,116 @@ def test_mi_sparse_column_names(self):
         ]
         self.assertEqual(head, expected)
 
+    def test_hide_single_index(self):
+        # single unnamed index
+        ctx = self.df.style._translate()
+        self.assertTrue(ctx['body'][0][0]['is_visible'])
+        self.assertTrue(ctx['head'][0][0]['is_visible'])
+        ctx2 = self.df.style.hide_index()._translate()
+        self.assertFalse(ctx2['body'][0][0]['is_visible'])
+        self.assertFalse(ctx2['head'][0][0]['is_visible'])
+
+        # single named index
+        ctx3 = self.df.set_index('A').style._translate()
+        self.assertTrue(ctx3['body'][0][0]['is_visible'])
+        self.assertEqual(len(ctx3['head']), 2)  # 2 header levels
+        self.assertTrue(ctx3['head'][0][0]['is_visible'])
+
+        ctx4 = self.df.set_index('A').style.hide_index()._translate()
+        self.assertFalse(ctx4['body'][0][0]['is_visible'])
+        self.assertEqual(len(ctx4['head']), 1)  # only 1 header levels
+        self.assertFalse(ctx4['head'][0][0]['is_visible'])
+
+    def test_hide_multiindex(self):
+        df = pd.DataFrame({'A': [1, 2]}, index=pd.MultiIndex.from_arrays(
+            [['a', 'a'], [0, 1]],
+            names=['idx_level_0', 'idx_level_1'])
+        )
+        ctx1 = df.style._translate()
+        # tests for 'a' and '0'
+        self.assertTrue(ctx1['body'][0][0]['is_visible'])
+        self.assertTrue(ctx1['body'][0][1]['is_visible'])
+        # check for blank header rows
+        self.assertTrue(ctx1['head'][0][0]['is_visible'])
+        self.assertTrue(ctx1['head'][0][1]['is_visible'])
+
+        ctx2 = df.style.hide_index()._translate()
+        # tests for 'a' and '0'
+        self.assertFalse(ctx2['body'][0][0]['is_visible'])
+        self.assertFalse(ctx2['body'][0][1]['is_visible'])
+        # check for blank header rows
+        self.assertFalse(ctx2['head'][0][0]['is_visible'])
+        self.assertFalse(ctx2['head'][0][1]['is_visible'])
+
+    def test_hide_columns_single_level(self):
+        # test hiding single column
+        ctx = self.df.style._translate()
+        self.assertTrue(ctx['head'][0][1]['is_visible'])
+        self.assertEqual(ctx['head'][0][1]['display_value'], 'A')
+        self.assertTrue(ctx['head'][0][2]['is_visible'])
+        self.assertEqual(ctx['head'][0][2]['display_value'], 'B')
+        self.assertTrue(ctx['body'][0][1]['is_visible'])  # col A, row 1
+        self.assertTrue(ctx['body'][1][2]['is_visible'])  # col B, row 1
+
+        ctx = self.df.style.hide_columns('A')._translate()
+        self.assertFalse(ctx['head'][0][1]['is_visible'])
+        self.assertFalse(ctx['body'][0][1]['is_visible'])  # col A, row 1
+        self.assertTrue(ctx['body'][1][2]['is_visible'])  # col B, row 1
+
+        # test hiding mulitiple columns
+        ctx = self.df.style.hide_columns(['A', 'B'])._translate()
+        self.assertFalse(ctx['head'][0][1]['is_visible'])
+        self.assertFalse(ctx['head'][0][2]['is_visible'])
+        self.assertFalse(ctx['body'][0][1]['is_visible'])  # col A, row 1
+        self.assertFalse(ctx['body'][1][2]['is_visible'])  # col B, row 1
+
+    def test_hide_columns_mult_levels(self):
+        # setup dataframe with multiple column levels and indices
+        i1 = pd.MultiIndex.from_arrays([['a', 'a'], [0, 1]],
+                                       names=['idx_level_0',
+                                              'idx_level_1'])
+        i2 = pd.MultiIndex.from_arrays([['b', 'b'], [0, 1]],
+                                       names=['col_level_0',
+                                              'col_level_1'])
+        df = pd.DataFrame([[1, 2], [3, 4]], index=i1, columns=i2)
+        ctx = df.style._translate()
+        # column headers
+        self.assertTrue(ctx['head'][0][2]['is_visible'])
+        self.assertTrue(ctx['head'][1][2]['is_visible'])
+        self.assertEqual(ctx['head'][1][3]['display_value'], 1)
+        # indices
+        self.assertTrue(ctx['body'][0][0]['is_visible'])
+        # data
+        self.assertTrue(ctx['body'][1][2]['is_visible'])
+        self.assertEqual(ctx['body'][1][2]['display_value'], 3)
+        self.assertTrue(ctx['body'][1][3]['is_visible'])
+        self.assertEqual(ctx['body'][1][3]['display_value'], 4)
+
+        # hide top column level, which hides both columns
+        ctx = df.style.hide_columns('b')._translate()
+        self.assertFalse(ctx['head'][0][2]['is_visible'])  # b
+        self.assertFalse(ctx['head'][1][2]['is_visible'])  # 0
+        self.assertFalse(ctx['body'][1][2]['is_visible'])  # 3
+        self.assertTrue(ctx['body'][0][0]['is_visible'])  # index
+
+        # hide first column only
+        ctx = df.style.hide_columns([('b', 0)])._translate()
+        self.assertTrue(ctx['head'][0][2]['is_visible'])  # b
+        self.assertFalse(ctx['head'][1][2]['is_visible'])  # 0
+        self.assertFalse(ctx['body'][1][2]['is_visible'])  # 3
+        self.assertTrue(ctx['body'][1][3]['is_visible'])
+        self.assertEqual(ctx['body'][1][3]['display_value'], 4)
+
+        # hide second column and index
+        ctx = df.style.hide_columns([('b', 1)]).hide_index()._translate()
+        self.assertFalse(ctx['body'][0][0]['is_visible'])  # index
+        self.assertTrue(ctx['head'][0][2]['is_visible'])  # b
+        self.assertTrue(ctx['head'][1][2]['is_visible'])  # 0
+        self.assertFalse(ctx['head'][1][3]['is_visible'])  # 1
+        self.assertFalse(ctx['body'][1][3]['is_visible'])  # 4
+        self.assertTrue(ctx['body'][1][2]['is_visible'])
+        self.assertEqual(ctx['body'][1][2]['display_value'], 3)
+
 
 @tm.mplskip
 class TestStylerMatplotlibDep(TestCase):