fix ; rename cols -> columns

Author: nchmura4

pandas/io/formats/style.py

@@ -75,7 +75,7 @@ class Styler(object):
 
         .. versionadded:: 0.20.2
 
-    hidden_cols: IndexSlice, default None
+    hidden_columns: IndexSlice, default None
         hides a subset of columns from rendering
 
         .. versionadded:: 0.20.2
@@ -128,7 +128,7 @@ class Styler(object):
 
     def __init__(self, data, precision=None, table_styles=None, uuid=None,
                  caption=None, table_attributes=None, index=True,
-                 hidden_cols=None):
+                 hidden_columns=None):
         self.ctx = defaultdict(list)
         self._todo = []
 
@@ -151,9 +151,9 @@ def __init__(self, data, precision=None, table_styles=None, uuid=None,
         self.precision = precision
         self.table_attributes = table_attributes
         self.index_visible = index
-        if hidden_cols is None:
-            hidden_cols = []
-        self.hidden_cols = hidden_cols
+        if hidden_columns is None:
+            hidden_columns = []
+        self.hidden_columns = hidden_columns
 
         # display_funcs maps (row, col) -> formatting function
 
@@ -203,7 +203,7 @@ def _translate(self):
         ctx = self.ctx
         precision = self.precision
         index_visible = self.index_visible
-        hidden_cols = self.hidden_cols
+        hidden_columns = self.hidden_columns
         uuid = self.uuid or str(uuid1()).replace("-", "_")
         ROW_HEADING_CLASS = "row_heading"
         COL_HEADING_CLASS = "col_heading"
@@ -218,7 +218,7 @@ def format_attr(pair):
 
         # for sparsifying a MultiIndex
         idx_lengths = _get_level_lengths(self.index)
-        col_lengths = _get_level_lengths(self.columns, hidden_cols)
+        col_lengths = _get_level_lengths(self.columns, hidden_columns)
 
         cell_context = dict()
 
@@ -289,7 +289,7 @@ def format_attr(pair):
                 [{"type": "th",
                   "value": BLANK_VALUE,
                   "class": " ".join([BLANK_CLASS])
-                  }] * (len(clabels[0]) - len(hidden_cols)))
+                  }] * (len(clabels[0]) - len(hidden_columns)))
 
             head.append(index_header_row)
 
@@ -324,7 +324,7 @@ def format_attr(pair):
                     "class": " ".join(cs),
                     "id": "_".join(cs[1:]),
                     "display_value": formatter(value),
-                    "is_visible": (c not in hidden_cols)
+                    "is_visible": (c not in hidden_columns)
                 })
                 props = []
                 for x in ctx[r, c]:
@@ -482,7 +482,7 @@ def _copy(self, deepcopy=False):
                         caption=self.caption, uuid=self.uuid,
                         table_styles=self.table_styles,
                         index=self.index_visible,
-                        hidden_cols=self.hidden_cols)
+                        hidden_columns=self.hidden_columns)
         if deepcopy:
             styler.ctx = copy.deepcopy(self.ctx)
             styler._todo = copy.deepcopy(self._todo)
@@ -816,7 +816,7 @@ def hide_columns(self, subset):
         """
         subset = _non_reducing_slice(subset)
         hidden_df = self.data.loc[subset]
-        self.hidden_cols = self.columns.get_indexer_for(hidden_df.columns)
+        self.hidden_columns = self.columns.get_indexer_for(hidden_df.columns)
         return self
 
     # -----------------------------------------------------------------------

pandas/tests/io/formats/test_style.py

@@ -814,22 +814,22 @@ def test_mi_sparse_column_names(self):
     def test_hide_single_index(self):
         # single unnamed index
         ctx = self.df.style._translate()
-        assert(ctx['body'][0][0]['is_visible'])
-        assert(ctx['head'][0][0]['is_visible'])
+        assert ctx['body'][0][0]['is_visible']
+        assert ctx['head'][0][0]['is_visible']
         ctx2 = self.df.style.hide_index()._translate()
-        assert(not ctx2['body'][0][0]['is_visible'])
-        assert(not ctx2['head'][0][0]['is_visible'])
+        assert not ctx2['body'][0][0]['is_visible']
+        assert not ctx2['head'][0][0]['is_visible']
 
         # single named index
         ctx3 = self.df.set_index('A').style._translate()
-        assert(ctx3['body'][0][0]['is_visible'])
-        assert(len(ctx3['head']) == 2)  # 2 header levels
-        assert(ctx3['head'][0][0]['is_visible'])
+        assert ctx3['body'][0][0]['is_visible']
+        assert len(ctx3['head']) == 2  # 2 header levels
+        assert ctx3['head'][0][0]['is_visible']
 
         ctx4 = self.df.set_index('A').style.hide_index()._translate()
-        assert(not ctx4['body'][0][0]['is_visible'])
-        assert(len(ctx4['head']) == 1)  # only 1 header levels
-        assert(not ctx4['head'][0][0]['is_visible'])
+        assert not ctx4['body'][0][0]['is_visible']
+        assert len(ctx4['head']) == 1  # only 1 header levels
+        assert not ctx4['head'][0][0]['is_visible']
 
     def test_hide_multiindex(self):
         df = pd.DataFrame({'A': [1, 2]}, index=pd.MultiIndex.from_arrays(
@@ -838,41 +838,41 @@ def test_hide_multiindex(self):
         )
         ctx1 = df.style._translate()
         # tests for 'a' and '0'
-        assert(ctx1['body'][0][0]['is_visible'])
-        assert(ctx1['body'][0][1]['is_visible'])
+        assert ctx1['body'][0][0]['is_visible']
+        assert ctx1['body'][0][1]['is_visible']
         # check for blank header rows
-        assert(ctx1['head'][0][0]['is_visible'])
-        assert(ctx1['head'][0][1]['is_visible'])
+        assert ctx1['head'][0][0]['is_visible']
+        assert ctx1['head'][0][1]['is_visible']
 
         ctx2 = df.style.hide_index()._translate()
         # tests for 'a' and '0'
-        assert(not ctx2['body'][0][0]['is_visible'])
-        assert(not ctx2['body'][0][1]['is_visible'])
+        assert not ctx2['body'][0][0]['is_visible']
+        assert not ctx2['body'][0][1]['is_visible']
         # check for blank header rows
-        assert(not ctx2['head'][0][0]['is_visible'])
-        assert(not ctx2['head'][0][1]['is_visible'])
+        assert not ctx2['head'][0][0]['is_visible']
+        assert not ctx2['head'][0][1]['is_visible']
 
     def test_hide_columns_single_level(self):
         # test hiding single column
         ctx = self.df.style._translate()
-        assert(ctx['head'][0][1]['is_visible'])
-        assert(ctx['head'][0][1]['display_value'] == 'A')
-        assert(ctx['head'][0][2]['is_visible'])
-        assert(ctx['head'][0][2]['display_value'] == 'B')
-        assert(ctx['body'][0][1]['is_visible'])  # col A, row 1
-        assert(ctx['body'][1][2]['is_visible'])  # col B, row 1
+        assert ctx['head'][0][1]['is_visible']
+        assert ctx['head'][0][1]['display_value'] == 'A'
+        assert ctx['head'][0][2]['is_visible']
+        assert ctx['head'][0][2]['display_value'] == 'B'
+        assert ctx['body'][0][1]['is_visible']  # col A, row 1
+        assert ctx['body'][1][2]['is_visible']  # col B, row 1
 
         ctx = self.df.style.hide_columns('A')._translate()
-        assert(not ctx['head'][0][1]['is_visible'])
-        assert(not ctx['body'][0][1]['is_visible'])  # col A, row 1
-        assert(ctx['body'][1][2]['is_visible'])  # col B, row 1
+        assert not ctx['head'][0][1]['is_visible']
+        assert not ctx['body'][0][1]['is_visible']  # col A, row 1
+        assert ctx['body'][1][2]['is_visible']  # col B, row 1
 
         # test hiding mulitiple columns
         ctx = self.df.style.hide_columns(['A', 'B'])._translate()
-        assert(not ctx['head'][0][1]['is_visible'])
-        assert(not ctx['head'][0][2]['is_visible'])
-        assert(not ctx['body'][0][1]['is_visible'])  # col A, row 1
-        assert(not ctx['body'][1][2]['is_visible'])  # col B, row 1
+        assert not ctx['head'][0][1]['is_visible']
+        assert not ctx['head'][0][2]['is_visible']
+        assert not ctx['body'][0][1]['is_visible']  # col A, row 1
+        assert not 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
@@ -885,41 +885,41 @@ def test_hide_columns_mult_levels(self):
         df = pd.DataFrame([[1, 2], [3, 4]], index=i1, columns=i2)
         ctx = df.style._translate()
         # column headers
-        assert(ctx['head'][0][2]['is_visible'])
-        assert(ctx['head'][1][2]['is_visible'])
-        assert(ctx['head'][1][3]['display_value'] == 1)
+        assert ctx['head'][0][2]['is_visible']
+        assert ctx['head'][1][2]['is_visible']
+        assert ctx['head'][1][3]['display_value'] == 1
         # indices
-        assert(ctx['body'][0][0]['is_visible'])
+        assert ctx['body'][0][0]['is_visible']
         # data
-        assert(ctx['body'][1][2]['is_visible'])
-        assert(ctx['body'][1][2]['display_value'] == 3)
-        assert(ctx['body'][1][3]['is_visible'])
-        assert(ctx['body'][1][3]['display_value'] == 4)
+        assert ctx['body'][1][2]['is_visible']
+        assert ctx['body'][1][2]['display_value'] == 3
+        assert ctx['body'][1][3]['is_visible']
+        assert ctx['body'][1][3]['display_value'] == 4
 
         # hide top column level, which hides both columns
         ctx = df.style.hide_columns('b')._translate()
-        assert(not ctx['head'][0][2]['is_visible'])  # b
-        assert(not ctx['head'][1][2]['is_visible'])  # 0
-        assert(not ctx['body'][1][2]['is_visible'])  # 3
-        assert(ctx['body'][0][0]['is_visible'])  # index
+        assert not ctx['head'][0][2]['is_visible']  # b
+        assert not ctx['head'][1][2]['is_visible']  # 0
+        assert not ctx['body'][1][2]['is_visible']  # 3
+        assert ctx['body'][0][0]['is_visible']  # index
 
         # hide first column only
         ctx = df.style.hide_columns([('b', 0)])._translate()
-        assert(ctx['head'][0][2]['is_visible'])  # b
-        assert(not ctx['head'][1][2]['is_visible'])  # 0
-        assert(not ctx['body'][1][2]['is_visible'])  # 3
-        assert(ctx['body'][1][3]['is_visible'])
-        assert(ctx['body'][1][3]['display_value'] == 4)
+        assert ctx['head'][0][2]['is_visible']  # b
+        assert not ctx['head'][1][2]['is_visible']  # 0
+        assert not ctx['body'][1][2]['is_visible']  # 3
+        assert ctx['body'][1][3]['is_visible']
+        assert ctx['body'][1][3]['display_value'] == 4
 
         # hide second column and index
         ctx = df.style.hide_columns([('b', 1)]).hide_index()._translate()
-        assert(not ctx['body'][0][0]['is_visible'])  # index
-        assert(ctx['head'][0][2]['is_visible'])  # b
-        assert(ctx['head'][1][2]['is_visible'])  # 0
-        assert(not ctx['head'][1][3]['is_visible'])  # 1
-        assert(not ctx['body'][1][3]['is_visible'])  # 4
-        assert(ctx['body'][1][2]['is_visible'])
-        assert(ctx['body'][1][2]['display_value'] == 3)
+        assert not ctx['body'][0][0]['is_visible']  # index
+        assert ctx['head'][0][2]['is_visible']  # b
+        assert ctx['head'][1][2]['is_visible']  # 0
+        assert not ctx['head'][1][3]['is_visible']  # 1
+        assert not ctx['body'][1][3]['is_visible']  # 4
+        assert ctx['body'][1][2]['is_visible']
+        assert ctx['body'][1][2]['display_value'] == 3
 
 
 class TestStylerMatplotlibDep(object):