BUG: styler multiindex hiding indexes and columns alignment

pandas/io/formats/style_render.py

@@ -497,119 +497,131 @@ def _translate_body(
 
         body = []
         for r, row_tup in enumerate(self.data.itertuples()):
-            if r >= max_rows:  # used only to add a '...' trimmed row:
-                index_headers = [
-                    _element(
-                        "th",
-                        f"{row_heading_class} level{c} {trimmed_row_class}",
-                        "...",
-                        not self.hide_index_[c],
-                        attributes="",
-                    )
-                    for c in range(self.data.index.nlevels)
-                ]
-
-                data = [
-                    _element(
-                        "td",
-                        f"{data_class} col{c} {trimmed_row_class}",
-                        "...",
-                        (c not in self.hidden_columns),
-                        attributes="",
-                    )
-                    for c in range(max_cols)
-                ]
+            if r not in self.hidden_rows:
+                if r >= max_rows:  # used only to add a '...' trimmed row:
+                    index_headers = [
+                        _element(
+                            "th",
+                            f"{row_heading_class} level{c} {trimmed_row_class}",
+                            "...",
+                            not self.hide_index_[c],
+                            attributes="",
+                        )
+                        for c in range(self.data.index.nlevels)
+                    ]
 
-                if len(self.data.columns) > max_cols:
-                    # columns are also trimmed so we add the final element
-                    data.append(
+                    data = [
                         _element(
                             "td",
-                            f"{data_class} {trimmed_row_class} {trimmed_col_class}",
+                            f"{data_class} col{c} {trimmed_row_class}",
                             "...",
-                            True,
+                            (c not in self.hidden_columns),
                             attributes="",
                         )
-                    )
+                        for c in range(max_cols)
+                    ]
 
-                body.append(index_headers + data)
-                break
+                    if len(self.data.columns) > max_cols:
+                        # columns are also trimmed so we add the final element
+                        data.append(
+                            _element(
+                                "td",
+                                f"{data_class} {trimmed_row_class} {trimmed_col_class}",
+                                "...",
+                                True,
+                                attributes="",
+                            )
+                        )
 
-            index_headers = []
-            for c, value in enumerate(rlabels[r]):
-                header_element = _element(
-                    "th",
-                    f"{row_heading_class} level{c} row{r}",
-                    value,
-                    _is_visible(r, c, idx_lengths) and not self.hide_index_[c],
-                    display_value=self._display_funcs_index[(r, c)](value),
-                    attributes=(
-                        f'rowspan="{idx_lengths.get((c, r), 0)}"'
-                        if idx_lengths.get((c, r), 0) > 1
-                        else ""
-                    ),
-                )
+                    body.append(index_headers + data)
+                    break
 
-                if self.cell_ids:
-                    header_element["id"] = f"level{c}_row{r}"  # id is specified
-                if (r, c) in self.ctx_index and self.ctx_index[r, c]:
-                    # always add id if a style is specified
-                    header_element["id"] = f"level{c}_row{r}"
-                    self.cellstyle_map_index[tuple(self.ctx_index[r, c])].append(
-                        f"level{c}_row{r}"
+                index_headers = []
+                for c, value in enumerate(rlabels[r]):
+                    header_element = _element(
+                        "th",
+                        f"{row_heading_class} level{c} row{r}",
+                        value,
+                        _is_visible(r, c, idx_lengths) and not self.hide_index_[c],
+                        display_value=self._display_funcs_index[(r, c)](value),
+                        attributes=(
+                            f'rowspan="{idx_lengths.get((c, r), 0)}"'
+                            if idx_lengths.get((c, r), 0) > 1
+                            else ""
+                        ),
                     )
 
-                index_headers.append(header_element)
+                    if self.cell_ids:
+                        header_element["id"] = f"level{c}_row{r}"  # id is specified
+                    if (r, c) in self.ctx_index and self.ctx_index[r, c]:
+                        # always add id if a style is specified
+                        header_element["id"] = f"level{c}_row{r}"
+                        self.cellstyle_map_index[tuple(self.ctx_index[r, c])].append(
+                            f"level{c}_row{r}"
+                        )
 
-            data = []
-            for c, value in enumerate(row_tup[1:]):
-                if c >= max_cols:
-                    data.append(
-                        _element(
-                            "td",
-                            f"{data_class} row{r} {trimmed_col_class}",
-                            "...",
-                            True,
-                            attributes="",
+                    index_headers.append(header_element)
+
+                data = []
+                for c, value in enumerate(row_tup[1:]):
+                    if c >= max_cols:
+                        data.append(
+                            _element(
+                                "td",
+                                f"{data_class} row{r} {trimmed_col_class}",
+                                "...",
+                                True,
+                                attributes="",
+                            )
                         )
-                    )
-                    break
+                        break
 
-                # add custom classes from cell context
-                cls = ""
-                if (r, c) in self.cell_context:
-                    cls = " " + self.cell_context[r, c]
-
-                data_element = _element(
-                    "td",
-                    f"{data_class} row{r} col{c}{cls}",
-                    value,
-                    (c not in self.hidden_columns and r not in self.hidden_rows),
-                    attributes="",
-                    display_value=self._display_funcs[(r, c)](value),
-                )
+                    # add custom classes from cell context
+                    cls = ""
+                    if (r, c) in self.cell_context:
+                        cls = " " + self.cell_context[r, c]
 
-                if self.cell_ids:
-                    data_element["id"] = f"row{r}_col{c}"
-                if (r, c) in self.ctx and self.ctx[r, c]:
-                    # always add id if needed due to specified style
-                    data_element["id"] = f"row{r}_col{c}"
-                    self.cellstyle_map[tuple(self.ctx[r, c])].append(f"row{r}_col{c}")
+                    data_element = _element(
+                        "td",
+                        f"{data_class} row{r} col{c}{cls}",
+                        value,
+                        (c not in self.hidden_columns and r not in self.hidden_rows),
+                        attributes="",
+                        display_value=self._display_funcs[(r, c)](value),
+                    )
+
+                    if self.cell_ids:
+                        data_element["id"] = f"row{r}_col{c}"
+                    if (r, c) in self.ctx and self.ctx[r, c]:
+                        # always add id if needed due to specified style
+                        data_element["id"] = f"row{r}_col{c}"
+                        self.cellstyle_map[tuple(self.ctx[r, c])].append(
+                            f"row{r}_col{c}"
+                        )
 
-                data.append(data_element)
+                    data.append(data_element)
 
-            body.append(index_headers + data)
+                body.append(index_headers + data)
         return body
 
     def _translate_latex(self, d: dict) -> None:
         r"""
         Post-process the default render dict for the LaTeX template format.
 
         Processing items included are:
-          - Remove hidden columns from the non-headers part of the body.
-          - Place cellstyles directly in td cells rather than use cellstyle_map.
-          - Remove hidden indexes or reinsert missing th elements if part of multiindex
-            or multirow sparsification (so that \multirow and \multicol work correctly).
+
+        1) Remove hidden columns from the non-headers part of the body. This is done
+        so that there are no repeated "&" latex separators generated from the template.
+        Alternatively this logic could be refactored into the template/template
+        parsing function.
+
+        2) Place cellstyles directly in td cells rather than use cellstyle_map. This is
+        necessary for a LaTeX format where styles have to be coded for each cell
+        specifically.
+
+        3) Remove hidden indexes or reinsert missing th elements if part of multiindex
+        or multirow sparsification (so that \multirow and \multicol work correctly), and
+        there are the correct number of cells (possibly blank) in a row.
         """
         d["head"] = [
             [
@@ -619,8 +631,16 @@ def _translate_latex(self, d: dict) -> None:
             ]
             for r, row in enumerate(d["head"])
         ]
+
         body = []
-        for r, row in enumerate(d["body"]):
+        index_levels = self.data.index.nlevels
+        for r, row in zip(
+            [r for r in range(len(self.data.index)) if r not in self.hidden_rows],
+            d["body"],
+        ):
+            # note: cannot enumerate d["body"] because rows were dropped if hidden
+            # during _translate_body so must zip to acquire the true r-index associated
+            # with the ctx obj which contains the cell styles.
             if all(self.hide_index_):
                 row_body_headers = []
             else:
@@ -632,13 +652,13 @@ def _translate_latex(self, d: dict) -> None:
                         else "",
                         "cellstyle": self.ctx_index[r, c] if col["is_visible"] else [],
                     }
-                    for c, col in enumerate(row)
-                    if col["type"] == "th"
+                    for c, col in enumerate(row[:index_levels])
+                    if (col["type"] == "th" and not self.hide_index_[c])
                 ]
 
             row_body_cells = [
-                {**col, "cellstyle": self.ctx[r, c - self.data.index.nlevels]}
-                for c, col in enumerate(row)
+                {**col, "cellstyle": self.ctx[r, c]}
+                for c, col in enumerate(row[index_levels:])
                 if (col["is_visible"] and col["type"] == "td")
             ]
 

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

@@ -467,3 +467,72 @@ def test_maximums(styler_mi, rows, cols):
     assert ">5</td>" in result  # [[0,1], [4,5]] always visible
     assert (">8</td>" in result) is not rows  # first trimmed vertical element
     assert (">2</td>" in result) is not cols  # first trimmed horizontal element
+
+
+def test_hiding_index_columns_multiindex_alignment():
+    # gh 43644
+    midx = MultiIndex.from_product(
+        [["i0", "j0"], ["i1"], ["i2", "j2"]], names=["i-0", "i-1", "i-2"]
+    )
+    cidx = MultiIndex.from_product(
+        [["c0"], ["c1", "d1"], ["c2", "d2"]], names=["c-0", "c-1", "c-2"]
+    )
+    df = DataFrame(np.arange(16).reshape(4, 4), index=midx, columns=cidx)
+    styler = Styler(df, uuid_len=0)
+    styler.hide_index(level=1).hide_columns(level=0)
+    styler.hide_index([("j0", "i1", "j2")])
+    styler.hide_columns([("c0", "d1", "d2")])
+    result = styler.to_html()
+    expected = dedent(
+        """\
+    <style type="text/css">
+    </style>
+    <table id="T_">
+      <thead>
+        <tr>
+          <th class="blank" >&nbsp;</th>
+          <th class="index_name level1" >c-1</th>
+          <th id="T__level1_col0" class="col_heading level1 col0" colspan="2">c1</th>
+          <th id="T__level1_col2" class="col_heading level1 col2" >d1</th>
+        </tr>
+        <tr>
+          <th class="blank" >&nbsp;</th>
+          <th class="index_name level2" >c-2</th>
+          <th id="T__level2_col0" class="col_heading level2 col0" >c2</th>
+          <th id="T__level2_col1" class="col_heading level2 col1" >d2</th>
+          <th id="T__level2_col2" class="col_heading level2 col2" >c2</th>
+        </tr>
+        <tr>
+          <th class="index_name level0" >i-0</th>
+          <th class="index_name level2" >i-2</th>
+          <th class="blank col0" >&nbsp;</th>
+          <th class="blank col1" >&nbsp;</th>
+          <th class="blank col2" >&nbsp;</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <th id="T__level0_row0" class="row_heading level0 row0" rowspan="2">i0</th>
+          <th id="T__level2_row0" class="row_heading level2 row0" >i2</th>
+          <td id="T__row0_col0" class="data row0 col0" >0</td>
+          <td id="T__row0_col1" class="data row0 col1" >1</td>
+          <td id="T__row0_col2" class="data row0 col2" >2</td>
+        </tr>
+        <tr>
+          <th id="T__level2_row1" class="row_heading level2 row1" >j2</th>
+          <td id="T__row1_col0" class="data row1 col0" >4</td>
+          <td id="T__row1_col1" class="data row1 col1" >5</td>
+          <td id="T__row1_col2" class="data row1 col2" >6</td>
+        </tr>
+        <tr>
+          <th id="T__level0_row2" class="row_heading level0 row2" >j0</th>
+          <th id="T__level2_row2" class="row_heading level2 row2" >i2</th>
+          <td id="T__row2_col0" class="data row2 col0" >8</td>
+          <td id="T__row2_col1" class="data row2 col1" >9</td>
+          <td id="T__row2_col2" class="data row2 col2" >10</td>
+        </tr>
+      </tbody>
+    </table>
+    """
+    )
+    assert result == expected

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

@@ -1212,17 +1212,15 @@ def test_hide_columns_index_mult_levels(self):
         assert ctx["body"][1][2]["is_visible"]
         assert ctx["body"][1][2]["display_value"] == "3"
 
-        # hide top row level, which hides both rows
+        # hide top row level, which hides both rows so body empty
         ctx = df.style.hide_index("a")._translate(True, True)
-        for i in [0, 1, 2, 3]:
-            assert not ctx["body"][0][i]["is_visible"]
-            assert not ctx["body"][1][i]["is_visible"]
+        assert ctx["body"] == []
 
         # hide first row only
         ctx = df.style.hide_index(("a", 0))._translate(True, True)
         for i in [0, 1, 2, 3]:
-            assert not ctx["body"][0][i]["is_visible"]
-            assert ctx["body"][1][i]["is_visible"]
+            assert "row1" in ctx["body"][0][i]["class"]  # row0 not included in body
+            assert ctx["body"][0][i]["is_visible"]
 
     def test_pipe(self):
         def set_caption_from_template(styler, a, b):
@@ -1479,25 +1477,27 @@ def test_caption_raises(mi_styler, caption):
         mi_styler.set_caption(caption)
 
 
-@pytest.mark.parametrize("axis", ["index", "columns"])
-def test_hiding_headers_over_axis_no_sparsify(axis):
+def test_hiding_headers_over_index_no_sparsify():
     # GH 43464
     midx = MultiIndex.from_product([[1, 2], ["a", "a", "b"]])
-    df = DataFrame(
-        9,
-        index=midx if axis == "index" else [0],
-        columns=midx if axis == "columns" else [0],
-    )
+    df = DataFrame(9, index=midx, columns=[0])
+    ctx = df.style._translate(False, False)
+    assert len(ctx["body"]) == 6
+    ctx = df.style.hide_index((1, "a"))._translate(False, False)
+    assert len(ctx["body"]) == 4
+    assert "row2" in ctx["body"][0][0]["class"]
 
-    styler = getattr(df.style, f"hide_{axis}")((1, "a"))
-    ctx = styler._translate(False, False)
 
-    if axis == "columns":  # test column headers
-        for ix in [(0, 1), (0, 2), (1, 1), (1, 2)]:
-            assert ctx["head"][ix[0]][ix[1]]["is_visible"] is False
-    if axis == "index":  # test row headers
-        for ix in [(0, 0), (0, 1), (1, 0), (1, 1)]:
-            assert ctx["body"][ix[0]][ix[1]]["is_visible"] is False
+def test_hiding_headers_over_columns_no_sparsify():
+    # GH 43464
+    midx = MultiIndex.from_product([[1, 2], ["a", "a", "b"]])
+    df = DataFrame(9, columns=midx, index=[0])
+    ctx = df.style._translate(False, False)
+    for ix in [(0, 1), (0, 2), (1, 1), (1, 2)]:
+        assert ctx["head"][ix[0]][ix[1]]["is_visible"] is True
+    ctx = df.style.hide_columns((1, "a"))._translate(False, False)
+    for ix in [(0, 1), (0, 2), (1, 1), (1, 2)]:
+        assert ctx["head"][ix[0]][ix[1]]["is_visible"] is False
 
 
 def test_get_level_lengths_mi_hidden():