Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/excel/test_style.py

@@ -0,0 +1,298 @@
+import contextlib
+import time
+
+import numpy as np
+import pytest
+
+from pandas.compat import is_platform_windows
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    read_excel,
+)
+import pandas._testing as tm
+
+from pandas.io.excel import ExcelWriter
+from pandas.io.formats.excel import ExcelFormatter
+
+pytest.importorskip("jinja2")
+# jinja2 is currently required for Styler.__init__(). Technically Styler.to_excel
+# could compute styles and render to excel without jinja2, since there is no
+# 'template' file, but this needs the import error to delayed until render time.
+
+if is_platform_windows():
+    pytestmark = pytest.mark.single_cpu
+
+
+def assert_equal_cell_styles(cell1, cell2):
+    # TODO: should find a better way to check equality
+    assert cell1.alignment.__dict__ == cell2.alignment.__dict__
+    assert cell1.border.__dict__ == cell2.border.__dict__
+    assert cell1.fill.__dict__ == cell2.fill.__dict__
+    assert cell1.font.__dict__ == cell2.font.__dict__
+    assert cell1.number_format == cell2.number_format
+    assert cell1.protection.__dict__ == cell2.protection.__dict__
+
+
+@pytest.mark.parametrize(
+    "engine",
+    ["xlsxwriter", "openpyxl"],
+)
+def test_styler_to_excel_unstyled(engine):
+    # compare DataFrame.to_excel and Styler.to_excel when no styles applied
+    pytest.importorskip(engine)
+    df = DataFrame(np.random.default_rng(2).standard_normal((2, 2)))
+    with tm.ensure_clean(".xlsx") as path:
+        with ExcelWriter(path, engine=engine) as writer:
+            df.to_excel(writer, sheet_name="dataframe")
+            df.style.to_excel(writer, sheet_name="unstyled")
+
+        openpyxl = pytest.importorskip("openpyxl")  # test loading only with openpyxl
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
+            for col1, col2 in zip(wb["dataframe"].columns, wb["unstyled"].columns):
+                assert len(col1) == len(col2)
+                for cell1, cell2 in zip(col1, col2):
+                    assert cell1.value == cell2.value
+                    assert_equal_cell_styles(cell1, cell2)
+
+
+shared_style_params = [
+    (
+        "background-color: #111222",
+        ["fill", "fgColor", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    (
+        "color: #111222",
+        ["font", "color", "value"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    ("font-family: Arial;", ["font", "name"], "arial"),
+    ("font-weight: bold;", ["font", "b"], True),
+    ("font-style: italic;", ["font", "i"], True),
+    ("text-decoration: underline;", ["font", "u"], "single"),
+    ("number-format: $??,???.00;", ["number_format"], "$??,???.00"),
+    ("text-align: left;", ["alignment", "horizontal"], "left"),
+    (
+        "vertical-align: bottom;",
+        ["alignment", "vertical"],
+        {"xlsxwriter": None, "openpyxl": "bottom"},  # xlsxwriter Fails
+    ),
+    ("vertical-align: middle;", ["alignment", "vertical"], "center"),
+    # Border widths
+    ("border-left: 2pt solid red", ["border", "left", "style"], "medium"),
+    ("border-left: 1pt dotted red", ["border", "left", "style"], "dotted"),
+    ("border-left: 2pt dotted red", ["border", "left", "style"], "mediumDashDotDot"),
+    ("border-left: 1pt dashed red", ["border", "left", "style"], "dashed"),
+    ("border-left: 2pt dashed red", ["border", "left", "style"], "mediumDashed"),
+    ("border-left: 1pt solid red", ["border", "left", "style"], "thin"),
+    ("border-left: 3pt solid red", ["border", "left", "style"], "thick"),
+    # Border expansion
+    (
+        "border-left: 2pt solid #111222",
+        ["border", "left", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    ("border: 1pt solid red", ["border", "top", "style"], "thin"),
+    (
+        "border: 1pt solid #111222",
+        ["border", "top", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    ("border: 1pt solid red", ["border", "right", "style"], "thin"),
+    (
+        "border: 1pt solid #111222",
+        ["border", "right", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    ("border: 1pt solid red", ["border", "bottom", "style"], "thin"),
+    (
+        "border: 1pt solid #111222",
+        ["border", "bottom", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    ("border: 1pt solid red", ["border", "left", "style"], "thin"),
+    (
+        "border: 1pt solid #111222",
+        ["border", "left", "color", "rgb"],
+        {"xlsxwriter": "FF111222", "openpyxl": "00111222"},
+    ),
+    # Border styles
+    (
+        "border-left-style: hair; border-left-color: black",
+        ["border", "left", "style"],
+        "hair",
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "engine",
+    ["xlsxwriter", "openpyxl"],
+)
+@pytest.mark.parametrize("css, attrs, expected", shared_style_params)
+def test_styler_to_excel_basic(engine, css, attrs, expected):
+    pytest.importorskip(engine)
+    df = DataFrame(np.random.default_rng(2).standard_normal((1, 1)))
+    styler = df.style.map(lambda x: css)
+
+    with tm.ensure_clean(".xlsx") as path:
+        with ExcelWriter(path, engine=engine) as writer:
+            df.to_excel(writer, sheet_name="dataframe")
+            styler.to_excel(writer, sheet_name="styled")
+
+        openpyxl = pytest.importorskip("openpyxl")  # test loading only with openpyxl
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
+            # test unstyled data cell does not have expected styles
+            # test styled cell has expected styles
+            u_cell, s_cell = wb["dataframe"].cell(2, 2), wb["styled"].cell(2, 2)
+        for attr in attrs:
+            u_cell, s_cell = getattr(u_cell, attr, None), getattr(s_cell, attr)
+
+        if isinstance(expected, dict):
+            assert u_cell is None or u_cell != expected[engine]
+            assert s_cell == expected[engine]
+        else:
+            assert u_cell is None or u_cell != expected
+            assert s_cell == expected
+
+
+@pytest.mark.parametrize(
+    "engine",
+    ["xlsxwriter", "openpyxl"],
+)
+@pytest.mark.parametrize("css, attrs, expected", shared_style_params)
+def test_styler_to_excel_basic_indexes(engine, css, attrs, expected):
+    pytest.importorskip(engine)
+    df = DataFrame(np.random.default_rng(2).standard_normal((1, 1)))
+
+    styler = df.style
+    styler.map_index(lambda x: css, axis=0)
+    styler.map_index(lambda x: css, axis=1)
+
+    null_styler = df.style
+    null_styler.map(lambda x: "null: css;")
+    null_styler.map_index(lambda x: "null: css;", axis=0)
+    null_styler.map_index(lambda x: "null: css;", axis=1)
+
+    with tm.ensure_clean(".xlsx") as path:
+        with ExcelWriter(path, engine=engine) as writer:
+            null_styler.to_excel(writer, sheet_name="null_styled")
+            styler.to_excel(writer, sheet_name="styled")
+
+        openpyxl = pytest.importorskip("openpyxl")  # test loading only with openpyxl
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
+            # test null styled index cells does not have expected styles
+            # test styled cell has expected styles
+            ui_cell, si_cell = wb["null_styled"].cell(2, 1), wb["styled"].cell(2, 1)
+            uc_cell, sc_cell = wb["null_styled"].cell(1, 2), wb["styled"].cell(1, 2)
+        for attr in attrs:
+            ui_cell, si_cell = getattr(ui_cell, attr, None), getattr(si_cell, attr)
+            uc_cell, sc_cell = getattr(uc_cell, attr, None), getattr(sc_cell, attr)
+
+        if isinstance(expected, dict):
+            assert ui_cell is None or ui_cell != expected[engine]
+            assert si_cell == expected[engine]
+            assert uc_cell is None or uc_cell != expected[engine]
+            assert sc_cell == expected[engine]
+        else:
+            assert ui_cell is None or ui_cell != expected
+            assert si_cell == expected
+            assert uc_cell is None or uc_cell != expected
+            assert sc_cell == expected
+
+
+# From https://openpyxl.readthedocs.io/en/stable/api/openpyxl.styles.borders.html
+# Note: Leaving behavior of "width"-type styles undefined; user should use border-width
+# instead
+excel_border_styles = [
+    # "thin",
+    "dashed",
+    "mediumDashDot",
+    "dashDotDot",
+    "hair",
+    "dotted",
+    "mediumDashDotDot",
+    # "medium",
+    "double",
+    "dashDot",
+    "slantDashDot",
+    # "thick",
+    "mediumDashed",
+]
+
+
+@pytest.mark.parametrize(
+    "engine",
+    ["xlsxwriter", "openpyxl"],
+)
+@pytest.mark.parametrize("border_style", excel_border_styles)
+def test_styler_to_excel_border_style(engine, border_style):
+    css = f"border-left: {border_style} black thin"
+    attrs = ["border", "left", "style"]
+    expected = border_style
+
+    pytest.importorskip(engine)
+    df = DataFrame(np.random.default_rng(2).standard_normal((1, 1)))
+    styler = df.style.map(lambda x: css)
+
+    with tm.ensure_clean(".xlsx") as path:
+        with ExcelWriter(path, engine=engine) as writer:
+            df.to_excel(writer, sheet_name="dataframe")
+            styler.to_excel(writer, sheet_name="styled")
+
+        openpyxl = pytest.importorskip("openpyxl")  # test loading only with openpyxl
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
+            # test unstyled data cell does not have expected styles
+            # test styled cell has expected styles
+            u_cell, s_cell = wb["dataframe"].cell(2, 2), wb["styled"].cell(2, 2)
+        for attr in attrs:
+            u_cell, s_cell = getattr(u_cell, attr, None), getattr(s_cell, attr)
+
+        if isinstance(expected, dict):
+            assert u_cell is None or u_cell != expected[engine]
+            assert s_cell == expected[engine]
+        else:
+            assert u_cell is None or u_cell != expected
+            assert s_cell == expected
+
+
+def test_styler_custom_converter():
+    openpyxl = pytest.importorskip("openpyxl")
+
+    def custom_converter(css):
+        return {"font": {"color": {"rgb": "111222"}}}
+
+    df = DataFrame(np.random.default_rng(2).standard_normal((1, 1)))
+    styler = df.style.map(lambda x: "color: #888999")
+    with tm.ensure_clean(".xlsx") as path:
+        with ExcelWriter(path, engine="openpyxl") as writer:
+            ExcelFormatter(styler, style_converter=custom_converter).write(
+                writer, sheet_name="custom"
+            )
+
+        with contextlib.closing(openpyxl.load_workbook(path)) as wb:
+            assert wb["custom"].cell(2, 2).font.color.value == "00111222"
+
+
+@pytest.mark.single_cpu
+@td.skip_if_not_us_locale
+def test_styler_to_s3(s3_public_bucket, s3so):
+    # GH#46381
+
+    mock_bucket_name, target_file = s3_public_bucket.name, "test.xlsx"
+    df = DataFrame({"x": [1, 2, 3], "y": [2, 4, 6]})
+    styler = df.style.set_sticky(axis="index")
+    styler.to_excel(f"s3://{mock_bucket_name}/{target_file}", storage_options=s3so)
+    timeout = 5
+    while True:
+        if target_file in (obj.key for obj in s3_public_bucket.objects.all()):
+            break
+        time.sleep(0.1)
+        timeout -= 0.1
+        assert timeout > 0, "Timed out waiting for file to appear on moto"
+        result = read_excel(
+            f"s3://{mock_bucket_name}/{target_file}", index_col=0, storage_options=s3so
+        )
+        tm.assert_frame_equal(result, df)

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_bar.py

@@ -0,0 +1,358 @@
+import io
+
+import numpy as np
+import pytest
+
+from pandas import (
+    NA,
+    DataFrame,
+    read_csv,
+)
+
+pytest.importorskip("jinja2")
+
+
+def bar_grad(a=None, b=None, c=None, d=None):
+    """Used in multiple tests to simplify formatting of expected result"""
+    ret = [("width", "10em")]
+    if all(x is None for x in [a, b, c, d]):
+        return ret
+    return ret + [
+        (
+            "background",
+            f"linear-gradient(90deg,{','.join([x for x in [a, b, c, d] if x])})",
+        )
+    ]
+
+
+def no_bar():
+    return bar_grad()
+
+
+def bar_to(x, color="#d65f5f"):
+    return bar_grad(f" {color} {x:.1f}%", f" transparent {x:.1f}%")
+
+
+def bar_from_to(x, y, color="#d65f5f"):
+    return bar_grad(
+        f" transparent {x:.1f}%",
+        f" {color} {x:.1f}%",
+        f" {color} {y:.1f}%",
+        f" transparent {y:.1f}%",
+    )
+
+
+@pytest.fixture
+def df_pos():
+    return DataFrame([[1], [2], [3]])
+
+
+@pytest.fixture
+def df_neg():
+    return DataFrame([[-1], [-2], [-3]])
+
+
+@pytest.fixture
+def df_mix():
+    return DataFrame([[-3], [1], [2]])
+
+
+@pytest.mark.parametrize(
+    "align, exp",
+    [
+        ("left", [no_bar(), bar_to(50), bar_to(100)]),
+        ("right", [bar_to(100), bar_from_to(50, 100), no_bar()]),
+        ("mid", [bar_to(33.33), bar_to(66.66), bar_to(100)]),
+        ("zero", [bar_from_to(50, 66.7), bar_from_to(50, 83.3), bar_from_to(50, 100)]),
+        ("mean", [bar_to(50), no_bar(), bar_from_to(50, 100)]),
+        (2.0, [bar_to(50), no_bar(), bar_from_to(50, 100)]),
+        (np.median, [bar_to(50), no_bar(), bar_from_to(50, 100)]),
+    ],
+)
+def test_align_positive_cases(df_pos, align, exp):
+    # test different align cases for all positive values
+    result = df_pos.style.bar(align=align)._compute().ctx
+    expected = {(0, 0): exp[0], (1, 0): exp[1], (2, 0): exp[2]}
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "align, exp",
+    [
+        ("left", [bar_to(100), bar_to(50), no_bar()]),
+        ("right", [no_bar(), bar_from_to(50, 100), bar_to(100)]),
+        ("mid", [bar_from_to(66.66, 100), bar_from_to(33.33, 100), bar_to(100)]),
+        ("zero", [bar_from_to(33.33, 50), bar_from_to(16.66, 50), bar_to(50)]),
+        ("mean", [bar_from_to(50, 100), no_bar(), bar_to(50)]),
+        (-2.0, [bar_from_to(50, 100), no_bar(), bar_to(50)]),
+        (np.median, [bar_from_to(50, 100), no_bar(), bar_to(50)]),
+    ],
+)
+def test_align_negative_cases(df_neg, align, exp):
+    # test different align cases for all negative values
+    result = df_neg.style.bar(align=align)._compute().ctx
+    expected = {(0, 0): exp[0], (1, 0): exp[1], (2, 0): exp[2]}
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "align, exp",
+    [
+        ("left", [no_bar(), bar_to(80), bar_to(100)]),
+        ("right", [bar_to(100), bar_from_to(80, 100), no_bar()]),
+        ("mid", [bar_to(60), bar_from_to(60, 80), bar_from_to(60, 100)]),
+        ("zero", [bar_to(50), bar_from_to(50, 66.66), bar_from_to(50, 83.33)]),
+        ("mean", [bar_to(50), bar_from_to(50, 66.66), bar_from_to(50, 83.33)]),
+        (-0.0, [bar_to(50), bar_from_to(50, 66.66), bar_from_to(50, 83.33)]),
+        (np.nanmedian, [bar_to(50), no_bar(), bar_from_to(50, 62.5)]),
+    ],
+)
+@pytest.mark.parametrize("nans", [True, False])
+def test_align_mixed_cases(df_mix, align, exp, nans):
+    # test different align cases for mixed positive and negative values
+    # also test no impact of NaNs and no_bar
+    expected = {(0, 0): exp[0], (1, 0): exp[1], (2, 0): exp[2]}
+    if nans:
+        df_mix.loc[3, :] = np.nan
+        expected.update({(3, 0): no_bar()})
+    result = df_mix.style.bar(align=align)._compute().ctx
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "align, exp",
+    [
+        (
+            "left",
+            {
+                "index": [[no_bar(), no_bar()], [bar_to(100), bar_to(100)]],
+                "columns": [[no_bar(), bar_to(100)], [no_bar(), bar_to(100)]],
+                "none": [[no_bar(), bar_to(33.33)], [bar_to(66.66), bar_to(100)]],
+            },
+        ),
+        (
+            "mid",
+            {
+                "index": [[bar_to(33.33), bar_to(50)], [bar_to(100), bar_to(100)]],
+                "columns": [[bar_to(50), bar_to(100)], [bar_to(75), bar_to(100)]],
+                "none": [[bar_to(25), bar_to(50)], [bar_to(75), bar_to(100)]],
+            },
+        ),
+        (
+            "zero",
+            {
+                "index": [
+                    [bar_from_to(50, 66.66), bar_from_to(50, 75)],
+                    [bar_from_to(50, 100), bar_from_to(50, 100)],
+                ],
+                "columns": [
+                    [bar_from_to(50, 75), bar_from_to(50, 100)],
+                    [bar_from_to(50, 87.5), bar_from_to(50, 100)],
+                ],
+                "none": [
+                    [bar_from_to(50, 62.5), bar_from_to(50, 75)],
+                    [bar_from_to(50, 87.5), bar_from_to(50, 100)],
+                ],
+            },
+        ),
+        (
+            2,
+            {
+                "index": [
+                    [bar_to(50), no_bar()],
+                    [bar_from_to(50, 100), bar_from_to(50, 100)],
+                ],
+                "columns": [
+                    [bar_to(50), no_bar()],
+                    [bar_from_to(50, 75), bar_from_to(50, 100)],
+                ],
+                "none": [
+                    [bar_from_to(25, 50), no_bar()],
+                    [bar_from_to(50, 75), bar_from_to(50, 100)],
+                ],
+            },
+        ),
+    ],
+)
+@pytest.mark.parametrize("axis", ["index", "columns", "none"])
+def test_align_axis(align, exp, axis):
+    # test all axis combinations with positive values and different aligns
+    data = DataFrame([[1, 2], [3, 4]])
+    result = (
+        data.style.bar(align=align, axis=None if axis == "none" else axis)
+        ._compute()
+        .ctx
+    )
+    expected = {
+        (0, 0): exp[axis][0][0],
+        (0, 1): exp[axis][0][1],
+        (1, 0): exp[axis][1][0],
+        (1, 1): exp[axis][1][1],
+    }
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "values, vmin, vmax",
+    [
+        ("positive", 1.5, 2.5),
+        ("negative", -2.5, -1.5),
+        ("mixed", -2.5, 1.5),
+    ],
+)
+@pytest.mark.parametrize("nullify", [None, "vmin", "vmax"])  # test min/max separately
+@pytest.mark.parametrize("align", ["left", "right", "zero", "mid"])
+def test_vmin_vmax_clipping(df_pos, df_neg, df_mix, values, vmin, vmax, nullify, align):
+    # test that clipping occurs if any vmin > data_values or vmax < data_values
+    if align == "mid":  # mid acts as left or right in each case
+        if values == "positive":
+            align = "left"
+        elif values == "negative":
+            align = "right"
+    df = {"positive": df_pos, "negative": df_neg, "mixed": df_mix}[values]
+    vmin = None if nullify == "vmin" else vmin
+    vmax = None if nullify == "vmax" else vmax
+
+    clip_df = df.where(df <= (vmax if vmax else 999), other=vmax)
+    clip_df = clip_df.where(clip_df >= (vmin if vmin else -999), other=vmin)
+
+    result = (
+        df.style.bar(align=align, vmin=vmin, vmax=vmax, color=["red", "green"])
+        ._compute()
+        .ctx
+    )
+    expected = clip_df.style.bar(align=align, color=["red", "green"])._compute().ctx
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "values, vmin, vmax",
+    [
+        ("positive", 0.5, 4.5),
+        ("negative", -4.5, -0.5),
+        ("mixed", -4.5, 4.5),
+    ],
+)
+@pytest.mark.parametrize("nullify", [None, "vmin", "vmax"])  # test min/max separately
+@pytest.mark.parametrize("align", ["left", "right", "zero", "mid"])
+def test_vmin_vmax_widening(df_pos, df_neg, df_mix, values, vmin, vmax, nullify, align):
+    # test that widening occurs if any vmax > data_values or vmin < data_values
+    if align == "mid":  # mid acts as left or right in each case
+        if values == "positive":
+            align = "left"
+        elif values == "negative":
+            align = "right"
+    df = {"positive": df_pos, "negative": df_neg, "mixed": df_mix}[values]
+    vmin = None if nullify == "vmin" else vmin
+    vmax = None if nullify == "vmax" else vmax
+
+    expand_df = df.copy()
+    expand_df.loc[3, :], expand_df.loc[4, :] = vmin, vmax
+
+    result = (
+        df.style.bar(align=align, vmin=vmin, vmax=vmax, color=["red", "green"])
+        ._compute()
+        .ctx
+    )
+    expected = expand_df.style.bar(align=align, color=["red", "green"])._compute().ctx
+    assert result.items() <= expected.items()
+
+
+def test_numerics():
+    # test data is pre-selected for numeric values
+    data = DataFrame([[1, "a"], [2, "b"]])
+    result = data.style.bar()._compute().ctx
+    assert (0, 1) not in result
+    assert (1, 1) not in result
+
+
+@pytest.mark.parametrize(
+    "align, exp",
+    [
+        ("left", [no_bar(), bar_to(100, "green")]),
+        ("right", [bar_to(100, "red"), no_bar()]),
+        ("mid", [bar_to(25, "red"), bar_from_to(25, 100, "green")]),
+        ("zero", [bar_from_to(33.33, 50, "red"), bar_from_to(50, 100, "green")]),
+    ],
+)
+def test_colors_mixed(align, exp):
+    data = DataFrame([[-1], [3]])
+    result = data.style.bar(align=align, color=["red", "green"])._compute().ctx
+    assert result == {(0, 0): exp[0], (1, 0): exp[1]}
+
+
+def test_bar_align_height():
+    # test when keyword height is used 'no-repeat center' and 'background-size' present
+    data = DataFrame([[1], [2]])
+    result = data.style.bar(align="left", height=50)._compute().ctx
+    bg_s = "linear-gradient(90deg, #d65f5f 100.0%, transparent 100.0%) no-repeat center"
+    expected = {
+        (0, 0): [("width", "10em")],
+        (1, 0): [
+            ("width", "10em"),
+            ("background", bg_s),
+            ("background-size", "100% 50.0%"),
+        ],
+    }
+    assert result == expected
+
+
+def test_bar_value_error_raises():
+    df = DataFrame({"A": [-100, -60, -30, -20]})
+
+    msg = "`align` should be in {'left', 'right', 'mid', 'mean', 'zero'} or"
+    with pytest.raises(ValueError, match=msg):
+        df.style.bar(align="poorly", color=["#d65f5f", "#5fba7d"]).to_html()
+
+    msg = r"`width` must be a value in \[0, 100\]"
+    with pytest.raises(ValueError, match=msg):
+        df.style.bar(width=200).to_html()
+
+    msg = r"`height` must be a value in \[0, 100\]"
+    with pytest.raises(ValueError, match=msg):
+        df.style.bar(height=200).to_html()
+
+
+def test_bar_color_and_cmap_error_raises():
+    df = DataFrame({"A": [1, 2, 3, 4]})
+    msg = "`color` and `cmap` cannot both be given"
+    # Test that providing both color and cmap raises a ValueError
+    with pytest.raises(ValueError, match=msg):
+        df.style.bar(color="#d65f5f", cmap="viridis").to_html()
+
+
+def test_bar_invalid_color_type_error_raises():
+    df = DataFrame({"A": [1, 2, 3, 4]})
+    msg = (
+        r"`color` must be string or list or tuple of 2 strings,"
+        r"\(eg: color=\['#d65f5f', '#5fba7d'\]\)"
+    )
+    # Test that providing an invalid color type raises a ValueError
+    with pytest.raises(ValueError, match=msg):
+        df.style.bar(color=123).to_html()
+
+    # Test that providing a color list with more than two elements raises a ValueError
+    with pytest.raises(ValueError, match=msg):
+        df.style.bar(color=["#d65f5f", "#5fba7d", "#abcdef"]).to_html()
+
+
+def test_styler_bar_with_NA_values():
+    df1 = DataFrame({"A": [1, 2, NA, 4]})
+    df2 = DataFrame([[NA, NA], [NA, NA]])
+    expected_substring = "style type="
+    html_output1 = df1.style.bar(subset="A").to_html()
+    html_output2 = df2.style.bar(align="left", axis=None).to_html()
+    assert expected_substring in html_output1
+    assert expected_substring in html_output2
+
+
+def test_style_bar_with_pyarrow_NA_values():
+    data = """name,age,test1,test2,teacher
+        Adam,15,95.0,80,Ashby
+        Bob,16,81.0,82,Ashby
+        Dave,16,89.0,84,Jones
+        Fred,15,,88,Jones"""
+    df = read_csv(io.StringIO(data), dtype_backend="pyarrow")
+    expected_substring = "style type="
+    html_output = df.style.bar(subset="test1").to_html()
+    assert expected_substring in html_output

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_exceptions.py

@@ -0,0 +1,44 @@
+import pytest
+
+jinja2 = pytest.importorskip("jinja2")
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+)
+
+from pandas.io.formats.style import Styler
+
+
+@pytest.fixture
+def df():
+    return DataFrame(
+        data=[[0, -0.609], [1, -1.228]],
+        columns=["A", "B"],
+        index=["x", "y"],
+    )
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0)
+
+
+def test_concat_bad_columns(styler):
+    msg = "`other.data` must have same columns as `Styler.data"
+    with pytest.raises(ValueError, match=msg):
+        styler.concat(DataFrame([[1, 2]]).style)
+
+
+def test_concat_bad_type(styler):
+    msg = "`other` must be of type `Styler`"
+    with pytest.raises(TypeError, match=msg):
+        styler.concat(DataFrame([[1, 2]]))
+
+
+def test_concat_bad_index_levels(styler, df):
+    df = df.copy()
+    df.index = MultiIndex.from_tuples([(0, 0), (1, 1)])
+    msg = "number of index levels must be same in `other`"
+    with pytest.raises(ValueError, match=msg):
+        styler.concat(df.style)

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_format.py

@@ -0,0 +1,562 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NA,
+    DataFrame,
+    IndexSlice,
+    MultiIndex,
+    NaT,
+    Timestamp,
+    option_context,
+)
+
+pytest.importorskip("jinja2")
+from pandas.io.formats.style import Styler
+from pandas.io.formats.style_render import _str_escape
+
+
+@pytest.fixture
+def df():
+    return DataFrame(
+        data=[[0, -0.609], [1, -1.228]],
+        columns=["A", "B"],
+        index=["x", "y"],
+    )
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0)
+
+
+@pytest.fixture
+def df_multi():
+    return DataFrame(
+        data=np.arange(16).reshape(4, 4),
+        columns=MultiIndex.from_product([["A", "B"], ["a", "b"]]),
+        index=MultiIndex.from_product([["X", "Y"], ["x", "y"]]),
+    )
+
+
+@pytest.fixture
+def styler_multi(df_multi):
+    return Styler(df_multi, uuid_len=0)
+
+
+def test_display_format(styler):
+    ctx = styler.format("{:0.1f}")._translate(True, True)
+    assert all(["display_value" in c for c in row] for row in ctx["body"])
+    assert all([len(c["display_value"]) <= 3 for c in row[1:]] for row in ctx["body"])
+    assert len(ctx["body"][0][1]["display_value"].lstrip("-")) <= 3
+
+
+@pytest.mark.parametrize("index", [True, False])
+@pytest.mark.parametrize("columns", [True, False])
+def test_display_format_index(styler, index, columns):
+    exp_index = ["x", "y"]
+    if index:
+        styler.format_index(lambda v: v.upper(), axis=0)  # test callable
+        exp_index = ["X", "Y"]
+
+    exp_columns = ["A", "B"]
+    if columns:
+        styler.format_index("*{}*", axis=1)  # test string
+        exp_columns = ["*A*", "*B*"]
+
+    ctx = styler._translate(True, True)
+
+    for r, row in enumerate(ctx["body"]):
+        assert row[0]["display_value"] == exp_index[r]
+
+    for c, col in enumerate(ctx["head"][1:]):
+        assert col["display_value"] == exp_columns[c]
+
+
+def test_format_dict(styler):
+    ctx = styler.format({"A": "{:0.1f}", "B": "{0:.2%}"})._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == "0.0"
+    assert ctx["body"][0][2]["display_value"] == "-60.90%"
+
+
+def test_format_index_dict(styler):
+    ctx = styler.format_index({0: lambda v: v.upper()})._translate(True, True)
+    for i, val in enumerate(["X", "Y"]):
+        assert ctx["body"][i][0]["display_value"] == val
+
+
+def test_format_string(styler):
+    ctx = styler.format("{:.2f}")._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == "0.00"
+    assert ctx["body"][0][2]["display_value"] == "-0.61"
+    assert ctx["body"][1][1]["display_value"] == "1.00"
+    assert ctx["body"][1][2]["display_value"] == "-1.23"
+
+
+def test_format_callable(styler):
+    ctx = styler.format(lambda v: "neg" if v < 0 else "pos")._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == "pos"
+    assert ctx["body"][0][2]["display_value"] == "neg"
+    assert ctx["body"][1][1]["display_value"] == "pos"
+    assert ctx["body"][1][2]["display_value"] == "neg"
+
+
+def test_format_with_na_rep():
+    # GH 21527 28358
+    df = DataFrame([[None, None], [1.1, 1.2]], columns=["A", "B"])
+
+    ctx = df.style.format(None, na_rep="-")._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == "-"
+    assert ctx["body"][0][2]["display_value"] == "-"
+
+    ctx = df.style.format("{:.2%}", na_rep="-")._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == "-"
+    assert ctx["body"][0][2]["display_value"] == "-"
+    assert ctx["body"][1][1]["display_value"] == "110.00%"
+    assert ctx["body"][1][2]["display_value"] == "120.00%"
+
+    ctx = df.style.format("{:.2%}", na_rep="-", subset=["B"])._translate(True, True)
+    assert ctx["body"][0][2]["display_value"] == "-"
+    assert ctx["body"][1][2]["display_value"] == "120.00%"
+
+
+def test_format_index_with_na_rep():
+    df = DataFrame([[1, 2, 3, 4, 5]], columns=["A", None, np.nan, NaT, NA])
+    ctx = df.style.format_index(None, na_rep="--", axis=1)._translate(True, True)
+    assert ctx["head"][0][1]["display_value"] == "A"
+    for i in [2, 3, 4, 5]:
+        assert ctx["head"][0][i]["display_value"] == "--"
+
+
+def test_format_non_numeric_na():
+    # GH 21527 28358
+    df = DataFrame(
+        {
+            "object": [None, np.nan, "foo"],
+            "datetime": [None, NaT, Timestamp("20120101")],
+        }
+    )
+    ctx = df.style.format(None, na_rep="-")._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == "-"
+    assert ctx["body"][0][2]["display_value"] == "-"
+    assert ctx["body"][1][1]["display_value"] == "-"
+    assert ctx["body"][1][2]["display_value"] == "-"
+
+
+@pytest.mark.parametrize(
+    "func, attr, kwargs",
+    [
+        ("format", "_display_funcs", {}),
+        ("format_index", "_display_funcs_index", {"axis": 0}),
+        ("format_index", "_display_funcs_columns", {"axis": 1}),
+    ],
+)
+def test_format_clear(styler, func, attr, kwargs):
+    assert (0, 0) not in getattr(styler, attr)  # using default
+    getattr(styler, func)("{:.2f}", **kwargs)
+    assert (0, 0) in getattr(styler, attr)  # formatter is specified
+    getattr(styler, func)(**kwargs)
+    assert (0, 0) not in getattr(styler, attr)  # formatter cleared to default
+
+
+@pytest.mark.parametrize(
+    "escape, exp",
+    [
+        ("html", "&lt;&gt;&amp;&#34;%$#_{}~^\\~ ^ \\ "),
+        (
+            "latex",
+            '<>\\&"\\%\\$\\#\\_\\{\\}\\textasciitilde \\textasciicircum '
+            "\\textbackslash \\textasciitilde \\space \\textasciicircum \\space "
+            "\\textbackslash \\space ",
+        ),
+    ],
+)
+def test_format_escape_html(escape, exp):
+    chars = '<>&"%$#_{}~^\\~ ^ \\ '
+    df = DataFrame([[chars]])
+
+    s = Styler(df, uuid_len=0).format("&{0}&", escape=None)
+    expected = f'<td id="T__row0_col0" class="data row0 col0" >&{chars}&</td>'
+    assert expected in s.to_html()
+
+    # only the value should be escaped before passing to the formatter
+    s = Styler(df, uuid_len=0).format("&{0}&", escape=escape)
+    expected = f'<td id="T__row0_col0" class="data row0 col0" >&{exp}&</td>'
+    assert expected in s.to_html()
+
+    # also test format_index()
+    styler = Styler(DataFrame(columns=[chars]), uuid_len=0)
+    styler.format_index("&{0}&", escape=None, axis=1)
+    assert styler._translate(True, True)["head"][0][1]["display_value"] == f"&{chars}&"
+    styler.format_index("&{0}&", escape=escape, axis=1)
+    assert styler._translate(True, True)["head"][0][1]["display_value"] == f"&{exp}&"
+
+
+@pytest.mark.parametrize(
+    "chars, expected",
+    [
+        (
+            r"$ \$&%#_{}~^\ $ &%#_{}~^\ $",
+            "".join(
+                [
+                    r"$ \$&%#_{}~^\ $ ",
+                    r"\&\%\#\_\{\}\textasciitilde \textasciicircum ",
+                    r"\textbackslash \space \$",
+                ]
+            ),
+        ),
+        (
+            r"\( &%#_{}~^\ \) &%#_{}~^\ \(",
+            "".join(
+                [
+                    r"\( &%#_{}~^\ \) ",
+                    r"\&\%\#\_\{\}\textasciitilde \textasciicircum ",
+                    r"\textbackslash \space \textbackslash (",
+                ]
+            ),
+        ),
+        (
+            r"$\&%#_{}^\$",
+            r"\$\textbackslash \&\%\#\_\{\}\textasciicircum \textbackslash \$",
+        ),
+        (
+            r"$ \frac{1}{2} $ \( \frac{1}{2} \)",
+            "".join(
+                [
+                    r"$ \frac{1}{2} $",
+                    r" \textbackslash ( \textbackslash frac\{1\}\{2\} \textbackslash )",
+                ]
+            ),
+        ),
+    ],
+)
+def test_format_escape_latex_math(chars, expected):
+    # GH 51903
+    # latex-math escape works for each DataFrame cell separately. If we have
+    # a combination of dollar signs and brackets, the dollar sign would apply.
+    df = DataFrame([[chars]])
+    s = df.style.format("{0}", escape="latex-math")
+    assert s._translate(True, True)["body"][0][1]["display_value"] == expected
+
+
+def test_format_escape_na_rep():
+    # tests the na_rep is not escaped
+    df = DataFrame([['<>&"', None]])
+    s = Styler(df, uuid_len=0).format("X&{0}>X", escape="html", na_rep="&")
+    ex = '<td id="T__row0_col0" class="data row0 col0" >X&&lt;&gt;&amp;&#34;>X</td>'
+    expected2 = '<td id="T__row0_col1" class="data row0 col1" >&</td>'
+    assert ex in s.to_html()
+    assert expected2 in s.to_html()
+
+    # also test for format_index()
+    df = DataFrame(columns=['<>&"', None])
+    styler = Styler(df, uuid_len=0)
+    styler.format_index("X&{0}>X", escape="html", na_rep="&", axis=1)
+    ctx = styler._translate(True, True)
+    assert ctx["head"][0][1]["display_value"] == "X&&lt;&gt;&amp;&#34;>X"
+    assert ctx["head"][0][2]["display_value"] == "&"
+
+
+def test_format_escape_floats(styler):
+    # test given formatter for number format is not impacted by escape
+    s = styler.format("{:.1f}", escape="html")
+    for expected in [">0.0<", ">1.0<", ">-1.2<", ">-0.6<"]:
+        assert expected in s.to_html()
+    # tests precision of floats is not impacted by escape
+    s = styler.format(precision=1, escape="html")
+    for expected in [">0<", ">1<", ">-1.2<", ">-0.6<"]:
+        assert expected in s.to_html()
+
+
+@pytest.mark.parametrize("formatter", [5, True, [2.0]])
+@pytest.mark.parametrize("func", ["format", "format_index"])
+def test_format_raises(styler, formatter, func):
+    with pytest.raises(TypeError, match="expected str or callable"):
+        getattr(styler, func)(formatter)
+
+
+@pytest.mark.parametrize(
+    "precision, expected",
+    [
+        (1, ["1.0", "2.0", "3.2", "4.6"]),
+        (2, ["1.00", "2.01", "3.21", "4.57"]),
+        (3, ["1.000", "2.009", "3.212", "4.566"]),
+    ],
+)
+def test_format_with_precision(precision, expected):
+    # Issue #13257
+    df = DataFrame([[1.0, 2.0090, 3.2121, 4.566]], columns=[1.0, 2.0090, 3.2121, 4.566])
+    styler = Styler(df)
+    styler.format(precision=precision)
+    styler.format_index(precision=precision, axis=1)
+
+    ctx = styler._translate(True, True)
+    for col, exp in enumerate(expected):
+        assert ctx["body"][0][col + 1]["display_value"] == exp  # format test
+        assert ctx["head"][0][col + 1]["display_value"] == exp  # format_index test
+
+
+@pytest.mark.parametrize("axis", [0, 1])
+@pytest.mark.parametrize(
+    "level, expected",
+    [
+        (0, ["X", "X", "_", "_"]),  # level int
+        ("zero", ["X", "X", "_", "_"]),  # level name
+        (1, ["_", "_", "X", "X"]),  # other level int
+        ("one", ["_", "_", "X", "X"]),  # other level name
+        ([0, 1], ["X", "X", "X", "X"]),  # both levels
+        ([0, "zero"], ["X", "X", "_", "_"]),  # level int and name simultaneous
+        ([0, "one"], ["X", "X", "X", "X"]),  # both levels as int and name
+        (["one", "zero"], ["X", "X", "X", "X"]),  # both level names, reversed
+    ],
+)
+def test_format_index_level(axis, level, expected):
+    midx = MultiIndex.from_arrays([["_", "_"], ["_", "_"]], names=["zero", "one"])
+    df = DataFrame([[1, 2], [3, 4]])
+    if axis == 0:
+        df.index = midx
+    else:
+        df.columns = midx
+
+    styler = df.style.format_index(lambda v: "X", level=level, axis=axis)
+    ctx = styler._translate(True, True)
+
+    if axis == 0:  # compare index
+        result = [ctx["body"][s][0]["display_value"] for s in range(2)]
+        result += [ctx["body"][s][1]["display_value"] for s in range(2)]
+    else:  # compare columns
+        result = [ctx["head"][0][s + 1]["display_value"] for s in range(2)]
+        result += [ctx["head"][1][s + 1]["display_value"] for s in range(2)]
+
+    assert expected == result
+
+
+def test_format_subset():
+    df = DataFrame([[0.1234, 0.1234], [1.1234, 1.1234]], columns=["a", "b"])
+    ctx = df.style.format(
+        {"a": "{:0.1f}", "b": "{0:.2%}"}, subset=IndexSlice[0, :]
+    )._translate(True, True)
+    expected = "0.1"
+    raw_11 = "1.123400"
+    assert ctx["body"][0][1]["display_value"] == expected
+    assert ctx["body"][1][1]["display_value"] == raw_11
+    assert ctx["body"][0][2]["display_value"] == "12.34%"
+
+    ctx = df.style.format("{:0.1f}", subset=IndexSlice[0, :])._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == expected
+    assert ctx["body"][1][1]["display_value"] == raw_11
+
+    ctx = df.style.format("{:0.1f}", subset=IndexSlice["a"])._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == expected
+    assert ctx["body"][0][2]["display_value"] == "0.123400"
+
+    ctx = df.style.format("{:0.1f}", subset=IndexSlice[0, "a"])._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == expected
+    assert ctx["body"][1][1]["display_value"] == raw_11
+
+    ctx = df.style.format("{:0.1f}", subset=IndexSlice[[0, 1], ["a"]])._translate(
+        True, True
+    )
+    assert ctx["body"][0][1]["display_value"] == expected
+    assert ctx["body"][1][1]["display_value"] == "1.1"
+    assert ctx["body"][0][2]["display_value"] == "0.123400"
+    assert ctx["body"][1][2]["display_value"] == raw_11
+
+
+@pytest.mark.parametrize("formatter", [None, "{:,.1f}"])
+@pytest.mark.parametrize("decimal", [".", "*"])
+@pytest.mark.parametrize("precision", [None, 2])
+@pytest.mark.parametrize("func, col", [("format", 1), ("format_index", 0)])
+def test_format_thousands(formatter, decimal, precision, func, col):
+    styler = DataFrame([[1000000.123456789]], index=[1000000.123456789]).style
+    result = getattr(styler, func)(  # testing float
+        thousands="_", formatter=formatter, decimal=decimal, precision=precision
+    )._translate(True, True)
+    assert "1_000_000" in result["body"][0][col]["display_value"]
+
+    styler = DataFrame([[1000000]], index=[1000000]).style
+    result = getattr(styler, func)(  # testing int
+        thousands="_", formatter=formatter, decimal=decimal, precision=precision
+    )._translate(True, True)
+    assert "1_000_000" in result["body"][0][col]["display_value"]
+
+    styler = DataFrame([[1 + 1000000.123456789j]], index=[1 + 1000000.123456789j]).style
+    result = getattr(styler, func)(  # testing complex
+        thousands="_", formatter=formatter, decimal=decimal, precision=precision
+    )._translate(True, True)
+    assert "1_000_000" in result["body"][0][col]["display_value"]
+
+
+@pytest.mark.parametrize("formatter", [None, "{:,.4f}"])
+@pytest.mark.parametrize("thousands", [None, ",", "*"])
+@pytest.mark.parametrize("precision", [None, 4])
+@pytest.mark.parametrize("func, col", [("format", 1), ("format_index", 0)])
+def test_format_decimal(formatter, thousands, precision, func, col):
+    styler = DataFrame([[1000000.123456789]], index=[1000000.123456789]).style
+    result = getattr(styler, func)(  # testing float
+        decimal="_", formatter=formatter, thousands=thousands, precision=precision
+    )._translate(True, True)
+    assert "000_123" in result["body"][0][col]["display_value"]
+
+    styler = DataFrame([[1 + 1000000.123456789j]], index=[1 + 1000000.123456789j]).style
+    result = getattr(styler, func)(  # testing complex
+        decimal="_", formatter=formatter, thousands=thousands, precision=precision
+    )._translate(True, True)
+    assert "000_123" in result["body"][0][col]["display_value"]
+
+
+def test_str_escape_error():
+    msg = "`escape` only permitted in {'html', 'latex', 'latex-math'}, got "
+    with pytest.raises(ValueError, match=msg):
+        _str_escape("text", "bad_escape")
+
+    with pytest.raises(ValueError, match=msg):
+        _str_escape("text", [])
+
+    _str_escape(2.00, "bad_escape")  # OK since dtype is float
+
+
+def test_long_int_formatting():
+    df = DataFrame(data=[[1234567890123456789]], columns=["test"])
+    styler = df.style
+    ctx = styler._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == "1234567890123456789"
+
+    styler = df.style.format(thousands="_")
+    ctx = styler._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] == "1_234_567_890_123_456_789"
+
+
+def test_format_options():
+    df = DataFrame({"int": [2000, 1], "float": [1.009, None], "str": ["&<", "&~"]})
+    ctx = df.style._translate(True, True)
+
+    # test option: na_rep
+    assert ctx["body"][1][2]["display_value"] == "nan"
+    with option_context("styler.format.na_rep", "MISSING"):
+        ctx_with_op = df.style._translate(True, True)
+        assert ctx_with_op["body"][1][2]["display_value"] == "MISSING"
+
+    # test option: decimal and precision
+    assert ctx["body"][0][2]["display_value"] == "1.009000"
+    with option_context("styler.format.decimal", "_"):
+        ctx_with_op = df.style._translate(True, True)
+        assert ctx_with_op["body"][0][2]["display_value"] == "1_009000"
+    with option_context("styler.format.precision", 2):
+        ctx_with_op = df.style._translate(True, True)
+        assert ctx_with_op["body"][0][2]["display_value"] == "1.01"
+
+    # test option: thousands
+    assert ctx["body"][0][1]["display_value"] == "2000"
+    with option_context("styler.format.thousands", "_"):
+        ctx_with_op = df.style._translate(True, True)
+        assert ctx_with_op["body"][0][1]["display_value"] == "2_000"
+
+    # test option: escape
+    assert ctx["body"][0][3]["display_value"] == "&<"
+    assert ctx["body"][1][3]["display_value"] == "&~"
+    with option_context("styler.format.escape", "html"):
+        ctx_with_op = df.style._translate(True, True)
+        assert ctx_with_op["body"][0][3]["display_value"] == "&amp;&lt;"
+    with option_context("styler.format.escape", "latex"):
+        ctx_with_op = df.style._translate(True, True)
+        assert ctx_with_op["body"][1][3]["display_value"] == "\\&\\textasciitilde "
+    with option_context("styler.format.escape", "latex-math"):
+        ctx_with_op = df.style._translate(True, True)
+        assert ctx_with_op["body"][1][3]["display_value"] == "\\&\\textasciitilde "
+
+    # test option: formatter
+    with option_context("styler.format.formatter", {"int": "{:,.2f}"}):
+        ctx_with_op = df.style._translate(True, True)
+        assert ctx_with_op["body"][0][1]["display_value"] == "2,000.00"
+
+
+def test_precision_zero(df):
+    styler = Styler(df, precision=0)
+    ctx = styler._translate(True, True)
+    assert ctx["body"][0][2]["display_value"] == "-1"
+    assert ctx["body"][1][2]["display_value"] == "-1"
+
+
+@pytest.mark.parametrize(
+    "formatter, exp",
+    [
+        (lambda x: f"{x:.3f}", "9.000"),
+        ("{:.2f}", "9.00"),
+        ({0: "{:.1f}"}, "9.0"),
+        (None, "9"),
+    ],
+)
+def test_formatter_options_validator(formatter, exp):
+    df = DataFrame([[9]])
+    with option_context("styler.format.formatter", formatter):
+        assert f" {exp} " in df.style.to_latex()
+
+
+def test_formatter_options_raises():
+    msg = "Value must be an instance of"
+    with pytest.raises(ValueError, match=msg):
+        with option_context("styler.format.formatter", ["bad", "type"]):
+            DataFrame().style.to_latex()
+
+
+def test_1level_multiindex():
+    # GH 43383
+    midx = MultiIndex.from_product([[1, 2]], names=[""])
+    df = DataFrame(-1, index=midx, columns=[0, 1])
+    ctx = df.style._translate(True, True)
+    assert ctx["body"][0][0]["display_value"] == "1"
+    assert ctx["body"][0][0]["is_visible"] is True
+    assert ctx["body"][1][0]["display_value"] == "2"
+    assert ctx["body"][1][0]["is_visible"] is True
+
+
+def test_boolean_format():
+    # gh 46384: booleans do not collapse to integer representation on display
+    df = DataFrame([[True, False]])
+    ctx = df.style._translate(True, True)
+    assert ctx["body"][0][1]["display_value"] is True
+    assert ctx["body"][0][2]["display_value"] is False
+
+
+@pytest.mark.parametrize(
+    "hide, labels",
+    [
+        (False, [1, 2]),
+        (True, [1, 2, 3, 4]),
+    ],
+)
+def test_relabel_raise_length(styler_multi, hide, labels):
+    if hide:
+        styler_multi.hide(axis=0, subset=[("X", "x"), ("Y", "y")])
+    with pytest.raises(ValueError, match="``labels`` must be of length equal"):
+        styler_multi.relabel_index(labels=labels)
+
+
+def test_relabel_index(styler_multi):
+    labels = [(1, 2), (3, 4)]
+    styler_multi.hide(axis=0, subset=[("X", "x"), ("Y", "y")])
+    styler_multi.relabel_index(labels=labels)
+    ctx = styler_multi._translate(True, True)
+    assert {"value": "X", "display_value": 1}.items() <= ctx["body"][0][0].items()
+    assert {"value": "y", "display_value": 2}.items() <= ctx["body"][0][1].items()
+    assert {"value": "Y", "display_value": 3}.items() <= ctx["body"][1][0].items()
+    assert {"value": "x", "display_value": 4}.items() <= ctx["body"][1][1].items()
+
+
+def test_relabel_columns(styler_multi):
+    labels = [(1, 2), (3, 4)]
+    styler_multi.hide(axis=1, subset=[("A", "a"), ("B", "b")])
+    styler_multi.relabel_index(axis=1, labels=labels)
+    ctx = styler_multi._translate(True, True)
+    assert {"value": "A", "display_value": 1}.items() <= ctx["head"][0][3].items()
+    assert {"value": "B", "display_value": 3}.items() <= ctx["head"][0][4].items()
+    assert {"value": "b", "display_value": 2}.items() <= ctx["head"][1][3].items()
+    assert {"value": "a", "display_value": 4}.items() <= ctx["head"][1][4].items()
+
+
+def test_relabel_roundtrip(styler):
+    styler.relabel_index(["{}", "{}"])
+    ctx = styler._translate(True, True)
+    assert {"value": "x", "display_value": "x"}.items() <= ctx["body"][0][0].items()
+    assert {"value": "y", "display_value": "y"}.items() <= ctx["body"][1][0].items()

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_highlight.py

@@ -0,0 +1,218 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NA,
+    DataFrame,
+    IndexSlice,
+)
+
+pytest.importorskip("jinja2")
+
+from pandas.io.formats.style import Styler
+
+
+@pytest.fixture(params=[(None, "float64"), (NA, "Int64")])
+def df(request):
+    # GH 45804
+    return DataFrame(
+        {"A": [0, np.nan, 10], "B": [1, request.param[0], 2]}, dtype=request.param[1]
+    )
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0)
+
+
+def test_highlight_null(styler):
+    result = styler.highlight_null()._compute().ctx
+    expected = {
+        (1, 0): [("background-color", "red")],
+        (1, 1): [("background-color", "red")],
+    }
+    assert result == expected
+
+
+def test_highlight_null_subset(styler):
+    # GH 31345
+    result = (
+        styler.highlight_null(color="red", subset=["A"])
+        .highlight_null(color="green", subset=["B"])
+        ._compute()
+        .ctx
+    )
+    expected = {
+        (1, 0): [("background-color", "red")],
+        (1, 1): [("background-color", "green")],
+    }
+    assert result == expected
+
+
+@pytest.mark.parametrize("f", ["highlight_min", "highlight_max"])
+def test_highlight_minmax_basic(df, f):
+    expected = {
+        (0, 1): [("background-color", "red")],
+        # ignores NaN row,
+        (2, 0): [("background-color", "red")],
+    }
+    if f == "highlight_min":
+        df = -df
+    result = getattr(df.style, f)(axis=1, color="red")._compute().ctx
+    assert result == expected
+
+
+@pytest.mark.parametrize("f", ["highlight_min", "highlight_max"])
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"axis": None, "color": "red"},  # test axis
+        {"axis": 0, "subset": ["A"], "color": "red"},  # test subset and ignores NaN
+        {"axis": None, "props": "background-color: red"},  # test props
+    ],
+)
+def test_highlight_minmax_ext(df, f, kwargs):
+    expected = {(2, 0): [("background-color", "red")]}
+    if f == "highlight_min":
+        df = -df
+    result = getattr(df.style, f)(**kwargs)._compute().ctx
+    assert result == expected
+
+
+@pytest.mark.parametrize("f", ["highlight_min", "highlight_max"])
+@pytest.mark.parametrize("axis", [None, 0, 1])
+def test_highlight_minmax_nulls(f, axis):
+    # GH 42750
+    expected = {
+        (1, 0): [("background-color", "yellow")],
+        (1, 1): [("background-color", "yellow")],
+    }
+    if axis == 1:
+        expected.update({(2, 1): [("background-color", "yellow")]})
+
+    if f == "highlight_max":
+        df = DataFrame({"a": [NA, 1, None], "b": [np.nan, 1, -1]})
+    else:
+        df = DataFrame({"a": [NA, -1, None], "b": [np.nan, -1, 1]})
+
+    result = getattr(df.style, f)(axis=axis)._compute().ctx
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"left": 0, "right": 1},  # test basic range
+        {"left": 0, "right": 1, "props": "background-color: yellow"},  # test props
+        {"left": -100, "right": 100, "subset": IndexSlice[[0, 1], :]},  # test subset
+        {"left": 0, "subset": IndexSlice[[0, 1], :]},  # test no right
+        {"right": 1},  # test no left
+        {"left": [0, 0, 11], "axis": 0},  # test left as sequence
+        {"left": DataFrame({"A": [0, 0, 11], "B": [1, 1, 11]}), "axis": None},  # axis
+        {"left": 0, "right": [0, 1], "axis": 1},  # test sequence right
+    ],
+)
+def test_highlight_between(styler, kwargs):
+    expected = {
+        (0, 0): [("background-color", "yellow")],
+        (0, 1): [("background-color", "yellow")],
+    }
+    result = styler.highlight_between(**kwargs)._compute().ctx
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "arg, map, axis",
+    [
+        ("left", [1, 2], 0),  # 0 axis has 3 elements not 2
+        ("left", [1, 2, 3], 1),  # 1 axis has 2 elements not 3
+        ("left", np.array([[1, 2], [1, 2]]), None),  # df is (2,3) not (2,2)
+        ("right", [1, 2], 0),  # same tests as above for 'right' not 'left'
+        ("right", [1, 2, 3], 1),  # ..
+        ("right", np.array([[1, 2], [1, 2]]), None),  # ..
+    ],
+)
+def test_highlight_between_raises(arg, styler, map, axis):
+    msg = f"supplied '{arg}' is not correct shape"
+    with pytest.raises(ValueError, match=msg):
+        styler.highlight_between(**{arg: map, "axis": axis})._compute()
+
+
+def test_highlight_between_raises2(styler):
+    msg = "values can be 'both', 'left', 'right', or 'neither'"
+    with pytest.raises(ValueError, match=msg):
+        styler.highlight_between(inclusive="badstring")._compute()
+
+    with pytest.raises(ValueError, match=msg):
+        styler.highlight_between(inclusive=1)._compute()
+
+
+@pytest.mark.parametrize(
+    "inclusive, expected",
+    [
+        (
+            "both",
+            {
+                (0, 0): [("background-color", "yellow")],
+                (0, 1): [("background-color", "yellow")],
+            },
+        ),
+        ("neither", {}),
+        ("left", {(0, 0): [("background-color", "yellow")]}),
+        ("right", {(0, 1): [("background-color", "yellow")]}),
+    ],
+)
+def test_highlight_between_inclusive(styler, inclusive, expected):
+    kwargs = {"left": 0, "right": 1, "subset": IndexSlice[[0, 1], :]}
+    result = styler.highlight_between(**kwargs, inclusive=inclusive)._compute()
+    assert result.ctx == expected
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"q_left": 0.5, "q_right": 1, "axis": 0},  # base case
+        {"q_left": 0.5, "q_right": 1, "axis": None},  # test axis
+        {"q_left": 0, "q_right": 1, "subset": IndexSlice[2, :]},  # test subset
+        {"q_left": 0.5, "axis": 0},  # test no high
+        {"q_right": 1, "subset": IndexSlice[2, :], "axis": 1},  # test no low
+        {"q_left": 0.5, "axis": 0, "props": "background-color: yellow"},  # tst prop
+    ],
+)
+def test_highlight_quantile(styler, kwargs):
+    expected = {
+        (2, 0): [("background-color", "yellow")],
+        (2, 1): [("background-color", "yellow")],
+    }
+    result = styler.highlight_quantile(**kwargs)._compute().ctx
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "f,kwargs",
+    [
+        ("highlight_min", {"axis": 1, "subset": IndexSlice[1, :]}),
+        ("highlight_max", {"axis": 0, "subset": [0]}),
+        ("highlight_quantile", {"axis": None, "q_left": 0.6, "q_right": 0.8}),
+        ("highlight_between", {"subset": [0]}),
+    ],
+)
+@pytest.mark.parametrize(
+    "df",
+    [
+        DataFrame([[0, 10], [20, 30]], dtype=int),
+        DataFrame([[0, 10], [20, 30]], dtype=float),
+        DataFrame([[0, 10], [20, 30]], dtype="datetime64[ns]"),
+        DataFrame([[0, 10], [20, 30]], dtype=str),
+        DataFrame([[0, 10], [20, 30]], dtype="timedelta64[ns]"),
+    ],
+)
+def test_all_highlight_dtypes(f, kwargs, df):
+    if f == "highlight_quantile" and isinstance(df.iloc[0, 0], (str)):
+        return None  # quantile incompatible with str
+    if f == "highlight_between":
+        kwargs["left"] = df.iloc[1, 0]  # set the range low for testing
+
+    expected = {(1, 0): [("background-color", "yellow")]}
+    result = getattr(df.style, f)(**kwargs)._compute().ctx
+    assert result == expected

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_html.py

@@ -0,0 +1,1009 @@
+from textwrap import (
+    dedent,
+    indent,
+)
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    option_context,
+)
+
+jinja2 = pytest.importorskip("jinja2")
+from pandas.io.formats.style import Styler
+
+
+@pytest.fixture
+def env():
+    loader = jinja2.PackageLoader("pandas", "io/formats/templates")
+    env = jinja2.Environment(loader=loader, trim_blocks=True)
+    return env
+
+
+@pytest.fixture
+def styler():
+    return Styler(DataFrame([[2.61], [2.69]], index=["a", "b"], columns=["A"]))
+
+
+@pytest.fixture
+def styler_mi():
+    midx = MultiIndex.from_product([["a", "b"], ["c", "d"]])
+    return Styler(DataFrame(np.arange(16).reshape(4, 4), index=midx, columns=midx))
+
+
+@pytest.fixture
+def tpl_style(env):
+    return env.get_template("html_style.tpl")
+
+
+@pytest.fixture
+def tpl_table(env):
+    return env.get_template("html_table.tpl")
+
+
+def test_html_template_extends_options():
+    # make sure if templates are edited tests are updated as are setup fixtures
+    # to understand the dependency
+    with open("pandas/io/formats/templates/html.tpl", encoding="utf-8") as file:
+        result = file.read()
+    assert "{% include html_style_tpl %}" in result
+    assert "{% include html_table_tpl %}" in result
+
+
+def test_exclude_styles(styler):
+    result = styler.to_html(exclude_styles=True, doctype_html=True)
+    expected = dedent(
+        """\
+        <!DOCTYPE html>
+        <html>
+        <head>
+        <meta charset="utf-8">
+        </head>
+        <body>
+        <table>
+          <thead>
+            <tr>
+              <th >&nbsp;</th>
+              <th >A</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <th >a</th>
+              <td >2.610000</td>
+            </tr>
+            <tr>
+              <th >b</th>
+              <td >2.690000</td>
+            </tr>
+          </tbody>
+        </table>
+        </body>
+        </html>
+        """
+    )
+    assert result == expected
+
+
+def test_w3_html_format(styler):
+    styler.set_uuid("").set_table_styles([{"selector": "th", "props": "att2:v2;"}]).map(
+        lambda x: "att1:v1;"
+    ).set_table_attributes('class="my-cls1" style="attr3:v3;"').set_td_classes(
+        DataFrame(["my-cls2"], index=["a"], columns=["A"])
+    ).format(
+        "{:.1f}"
+    ).set_caption(
+        "A comprehensive test"
+    )
+    expected = dedent(
+        """\
+        <style type="text/css">
+        #T_ th {
+          att2: v2;
+        }
+        #T__row0_col0, #T__row1_col0 {
+          att1: v1;
+        }
+        </style>
+        <table id="T_" class="my-cls1" style="attr3:v3;">
+          <caption>A comprehensive test</caption>
+          <thead>
+            <tr>
+              <th class="blank level0" >&nbsp;</th>
+              <th id="T__level0_col0" class="col_heading level0 col0" >A</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <th id="T__level0_row0" class="row_heading level0 row0" >a</th>
+              <td id="T__row0_col0" class="data row0 col0 my-cls2" >2.6</td>
+            </tr>
+            <tr>
+              <th id="T__level0_row1" class="row_heading level0 row1" >b</th>
+              <td id="T__row1_col0" class="data row1 col0" >2.7</td>
+            </tr>
+          </tbody>
+        </table>
+        """
+    )
+    assert expected == styler.to_html()
+
+
+def test_colspan_w3():
+    # GH 36223
+    df = DataFrame(data=[[1, 2]], columns=[["l0", "l0"], ["l1a", "l1b"]])
+    styler = Styler(df, uuid="_", cell_ids=False)
+    assert '<th class="col_heading level0 col0" colspan="2">l0</th>' in styler.to_html()
+
+
+def test_rowspan_w3():
+    # GH 38533
+    df = DataFrame(data=[[1, 2]], index=[["l0", "l0"], ["l1a", "l1b"]])
+    styler = Styler(df, uuid="_", cell_ids=False)
+    assert '<th class="row_heading level0 row0" rowspan="2">l0</th>' in styler.to_html()
+
+
+def test_styles(styler):
+    styler.set_uuid("abc")
+    styler.set_table_styles([{"selector": "td", "props": "color: red;"}])
+    result = styler.to_html(doctype_html=True)
+    expected = dedent(
+        """\
+        <!DOCTYPE html>
+        <html>
+        <head>
+        <meta charset="utf-8">
+        <style type="text/css">
+        #T_abc td {
+          color: red;
+        }
+        </style>
+        </head>
+        <body>
+        <table id="T_abc">
+          <thead>
+            <tr>
+              <th class="blank level0" >&nbsp;</th>
+              <th id="T_abc_level0_col0" class="col_heading level0 col0" >A</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <th id="T_abc_level0_row0" class="row_heading level0 row0" >a</th>
+              <td id="T_abc_row0_col0" class="data row0 col0" >2.610000</td>
+            </tr>
+            <tr>
+              <th id="T_abc_level0_row1" class="row_heading level0 row1" >b</th>
+              <td id="T_abc_row1_col0" class="data row1 col0" >2.690000</td>
+            </tr>
+          </tbody>
+        </table>
+        </body>
+        </html>
+        """
+    )
+    assert result == expected
+
+
+def test_doctype(styler):
+    result = styler.to_html(doctype_html=False)
+    assert "<html>" not in result
+    assert "<body>" not in result
+    assert "<!DOCTYPE html>" not in result
+    assert "<head>" not in result
+
+
+def test_doctype_encoding(styler):
+    with option_context("styler.render.encoding", "ASCII"):
+        result = styler.to_html(doctype_html=True)
+        assert '<meta charset="ASCII">' in result
+        result = styler.to_html(doctype_html=True, encoding="ANSI")
+        assert '<meta charset="ANSI">' in result
+
+
+def test_bold_headers_arg(styler):
+    result = styler.to_html(bold_headers=True)
+    assert "th {\n  font-weight: bold;\n}" in result
+    result = styler.to_html()
+    assert "th {\n  font-weight: bold;\n}" not in result
+
+
+def test_caption_arg(styler):
+    result = styler.to_html(caption="foo bar")
+    assert "<caption>foo bar</caption>" in result
+    result = styler.to_html()
+    assert "<caption>foo bar</caption>" not in result
+
+
+def test_block_names(tpl_style, tpl_table):
+    # catch accidental removal of a block
+    expected_style = {
+        "before_style",
+        "style",
+        "table_styles",
+        "before_cellstyle",
+        "cellstyle",
+    }
+    expected_table = {
+        "before_table",
+        "table",
+        "caption",
+        "thead",
+        "tbody",
+        "after_table",
+        "before_head_rows",
+        "head_tr",
+        "after_head_rows",
+        "before_rows",
+        "tr",
+        "after_rows",
+    }
+    result1 = set(tpl_style.blocks)
+    assert result1 == expected_style
+
+    result2 = set(tpl_table.blocks)
+    assert result2 == expected_table
+
+
+def test_from_custom_template_table(tmpdir):
+    p = tmpdir.mkdir("tpl").join("myhtml_table.tpl")
+    p.write(
+        dedent(
+            """\
+            {% extends "html_table.tpl" %}
+            {% block table %}
+            <h1>{{custom_title}}</h1>
+            {{ super() }}
+            {% endblock table %}"""
+        )
+    )
+    result = Styler.from_custom_template(str(tmpdir.join("tpl")), "myhtml_table.tpl")
+    assert issubclass(result, Styler)
+    assert result.env is not Styler.env
+    assert result.template_html_table is not Styler.template_html_table
+    styler = result(DataFrame({"A": [1, 2]}))
+    assert "<h1>My Title</h1>\n\n\n<table" in styler.to_html(custom_title="My Title")
+
+
+def test_from_custom_template_style(tmpdir):
+    p = tmpdir.mkdir("tpl").join("myhtml_style.tpl")
+    p.write(
+        dedent(
+            """\
+            {% extends "html_style.tpl" %}
+            {% block style %}
+            <link rel="stylesheet" href="mystyle.css">
+            {{ super() }}
+            {% endblock style %}"""
+        )
+    )
+    result = Styler.from_custom_template(
+        str(tmpdir.join("tpl")), html_style="myhtml_style.tpl"
+    )
+    assert issubclass(result, Styler)
+    assert result.env is not Styler.env
+    assert result.template_html_style is not Styler.template_html_style
+    styler = result(DataFrame({"A": [1, 2]}))
+    assert '<link rel="stylesheet" href="mystyle.css">\n\n<style' in styler.to_html()
+
+
+def test_caption_as_sequence(styler):
+    styler.set_caption(("full cap", "short cap"))
+    assert "<caption>full cap</caption>" in styler.to_html()
+
+
+@pytest.mark.parametrize("index", [False, True])
+@pytest.mark.parametrize("columns", [False, True])
+@pytest.mark.parametrize("index_name", [True, False])
+def test_sticky_basic(styler, index, columns, index_name):
+    if index_name:
+        styler.index.name = "some text"
+    if index:
+        styler.set_sticky(axis=0)
+    if columns:
+        styler.set_sticky(axis=1)
+
+    left_css = (
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
+        "  left: 0px;\n  z-index: {1};\n}}"
+    )
+    top_css = (
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
+        "  top: {1}px;\n  z-index: {2};\n{3}}}"
+    )
+
+    res = styler.set_uuid("").to_html()
+
+    # test index stickys over thead and tbody
+    assert (left_css.format("thead tr th:nth-child(1)", "3 !important") in res) is index
+    assert (left_css.format("tbody tr th:nth-child(1)", "1") in res) is index
+
+    # test column stickys including if name row
+    assert (
+        top_css.format("thead tr:nth-child(1) th", "0", "2", "  height: 25px;\n") in res
+    ) is (columns and index_name)
+    assert (
+        top_css.format("thead tr:nth-child(2) th", "25", "2", "  height: 25px;\n")
+        in res
+    ) is (columns and index_name)
+    assert (top_css.format("thead tr:nth-child(1) th", "0", "2", "") in res) is (
+        columns and not index_name
+    )
+
+
+@pytest.mark.parametrize("index", [False, True])
+@pytest.mark.parametrize("columns", [False, True])
+def test_sticky_mi(styler_mi, index, columns):
+    if index:
+        styler_mi.set_sticky(axis=0)
+    if columns:
+        styler_mi.set_sticky(axis=1)
+
+    left_css = (
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
+        "  left: {1}px;\n  min-width: 75px;\n  max-width: 75px;\n  z-index: {2};\n}}"
+    )
+    top_css = (
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
+        "  top: {1}px;\n  height: 25px;\n  z-index: {2};\n}}"
+    )
+
+    res = styler_mi.set_uuid("").to_html()
+
+    # test the index stickys for thead and tbody over both levels
+    assert (
+        left_css.format("thead tr th:nth-child(1)", "0", "3 !important") in res
+    ) is index
+    assert (left_css.format("tbody tr th.level0", "0", "1") in res) is index
+    assert (
+        left_css.format("thead tr th:nth-child(2)", "75", "3 !important") in res
+    ) is index
+    assert (left_css.format("tbody tr th.level1", "75", "1") in res) is index
+
+    # test the column stickys for each level row
+    assert (top_css.format("thead tr:nth-child(1) th", "0", "2") in res) is columns
+    assert (top_css.format("thead tr:nth-child(2) th", "25", "2") in res) is columns
+
+
+@pytest.mark.parametrize("index", [False, True])
+@pytest.mark.parametrize("columns", [False, True])
+@pytest.mark.parametrize("levels", [[1], ["one"], "one"])
+def test_sticky_levels(styler_mi, index, columns, levels):
+    styler_mi.index.names, styler_mi.columns.names = ["zero", "one"], ["zero", "one"]
+    if index:
+        styler_mi.set_sticky(axis=0, levels=levels)
+    if columns:
+        styler_mi.set_sticky(axis=1, levels=levels)
+
+    left_css = (
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
+        "  left: {1}px;\n  min-width: 75px;\n  max-width: 75px;\n  z-index: {2};\n}}"
+    )
+    top_css = (
+        "#T_ {0} {{\n  position: sticky;\n  background-color: inherit;\n"
+        "  top: {1}px;\n  height: 25px;\n  z-index: {2};\n}}"
+    )
+
+    res = styler_mi.set_uuid("").to_html()
+
+    # test no sticking of level0
+    assert "#T_ thead tr th:nth-child(1)" not in res
+    assert "#T_ tbody tr th.level0" not in res
+    assert "#T_ thead tr:nth-child(1) th" not in res
+
+    # test sticking level1
+    assert (
+        left_css.format("thead tr th:nth-child(2)", "0", "3 !important") in res
+    ) is index
+    assert (left_css.format("tbody tr th.level1", "0", "1") in res) is index
+    assert (top_css.format("thead tr:nth-child(2) th", "0", "2") in res) is columns
+
+
+def test_sticky_raises(styler):
+    with pytest.raises(ValueError, match="No axis named bad for object type DataFrame"):
+        styler.set_sticky(axis="bad")
+
+
+@pytest.mark.parametrize(
+    "sparse_index, sparse_columns",
+    [(True, True), (True, False), (False, True), (False, False)],
+)
+def test_sparse_options(sparse_index, sparse_columns):
+    cidx = MultiIndex.from_tuples([("Z", "a"), ("Z", "b"), ("Y", "c")])
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=ridx, columns=cidx)
+    styler = df.style
+
+    default_html = styler.to_html()  # defaults under pd.options to (True , True)
+
+    with option_context(
+        "styler.sparse.index", sparse_index, "styler.sparse.columns", sparse_columns
+    ):
+        html1 = styler.to_html()
+        assert (html1 == default_html) is (sparse_index and sparse_columns)
+    html2 = styler.to_html(sparse_index=sparse_index, sparse_columns=sparse_columns)
+    assert html1 == html2
+
+
+@pytest.mark.parametrize("index", [True, False])
+@pytest.mark.parametrize("columns", [True, False])
+def test_map_header_cell_ids(styler, index, columns):
+    # GH 41893
+    func = lambda v: "attr: val;"
+    styler.uuid, styler.cell_ids = "", False
+    if index:
+        styler.map_index(func, axis="index")
+    if columns:
+        styler.map_index(func, axis="columns")
+
+    result = styler.to_html()
+
+    # test no data cell ids
+    assert '<td class="data row0 col0" >2.610000</td>' in result
+    assert '<td class="data row1 col0" >2.690000</td>' in result
+
+    # test index header ids where needed and css styles
+    assert (
+        '<th id="T__level0_row0" class="row_heading level0 row0" >a</th>' in result
+    ) is index
+    assert (
+        '<th id="T__level0_row1" class="row_heading level0 row1" >b</th>' in result
+    ) is index
+    assert ("#T__level0_row0, #T__level0_row1 {\n  attr: val;\n}" in result) is index
+
+    # test column header ids where needed and css styles
+    assert (
+        '<th id="T__level0_col0" class="col_heading level0 col0" >A</th>' in result
+    ) is columns
+    assert ("#T__level0_col0 {\n  attr: val;\n}" in result) is columns
+
+
+@pytest.mark.parametrize("rows", [True, False])
+@pytest.mark.parametrize("cols", [True, False])
+def test_maximums(styler_mi, rows, cols):
+    result = styler_mi.to_html(
+        max_rows=2 if rows else None,
+        max_columns=2 if cols else None,
+    )
+
+    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_replaced_css_class_names():
+    css = {
+        "row_heading": "ROWHEAD",
+        # "col_heading": "COLHEAD",
+        "index_name": "IDXNAME",
+        # "col": "COL",
+        "row": "ROW",
+        # "col_trim": "COLTRIM",
+        "row_trim": "ROWTRIM",
+        "level": "LEVEL",
+        "data": "DATA",
+        "blank": "BLANK",
+    }
+    midx = MultiIndex.from_product([["a", "b"], ["c", "d"]])
+    styler_mi = Styler(
+        DataFrame(np.arange(16).reshape(4, 4), index=midx, columns=midx),
+        uuid_len=0,
+    ).set_table_styles(css_class_names=css)
+    styler_mi.index.names = ["n1", "n2"]
+    styler_mi.hide(styler_mi.index[1:], axis=0)
+    styler_mi.hide(styler_mi.columns[1:], axis=1)
+    styler_mi.map_index(lambda v: "color: red;", axis=0)
+    styler_mi.map_index(lambda v: "color: green;", axis=1)
+    styler_mi.map(lambda v: "color: blue;")
+    expected = dedent(
+        """\
+    <style type="text/css">
+    #T__ROW0_col0 {
+      color: blue;
+    }
+    #T__LEVEL0_ROW0, #T__LEVEL1_ROW0 {
+      color: red;
+    }
+    #T__LEVEL0_col0, #T__LEVEL1_col0 {
+      color: green;
+    }
+    </style>
+    <table id="T_">
+      <thead>
+        <tr>
+          <th class="BLANK" >&nbsp;</th>
+          <th class="IDXNAME LEVEL0" >n1</th>
+          <th id="T__LEVEL0_col0" class="col_heading LEVEL0 col0" >a</th>
+        </tr>
+        <tr>
+          <th class="BLANK" >&nbsp;</th>
+          <th class="IDXNAME LEVEL1" >n2</th>
+          <th id="T__LEVEL1_col0" class="col_heading LEVEL1 col0" >c</th>
+        </tr>
+        <tr>
+          <th class="IDXNAME LEVEL0" >n1</th>
+          <th class="IDXNAME LEVEL1" >n2</th>
+          <th class="BLANK col0" >&nbsp;</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <th id="T__LEVEL0_ROW0" class="ROWHEAD LEVEL0 ROW0" >a</th>
+          <th id="T__LEVEL1_ROW0" class="ROWHEAD LEVEL1 ROW0" >c</th>
+          <td id="T__ROW0_col0" class="DATA ROW0 col0" >0</td>
+        </tr>
+      </tbody>
+    </table>
+    """
+    )
+    result = styler_mi.to_html()
+    assert result == expected
+
+
+def test_include_css_style_rules_only_for_visible_cells(styler_mi):
+    # GH 43619
+    result = (
+        styler_mi.set_uuid("")
+        .map(lambda v: "color: blue;")
+        .hide(styler_mi.data.columns[1:], axis="columns")
+        .hide(styler_mi.data.index[1:], axis="index")
+        .to_html()
+    )
+    expected_styles = dedent(
+        """\
+        <style type="text/css">
+        #T__row0_col0 {
+          color: blue;
+        }
+        </style>
+        """
+    )
+    assert expected_styles in result
+
+
+def test_include_css_style_rules_only_for_visible_index_labels(styler_mi):
+    # GH 43619
+    result = (
+        styler_mi.set_uuid("")
+        .map_index(lambda v: "color: blue;", axis="index")
+        .hide(styler_mi.data.columns, axis="columns")
+        .hide(styler_mi.data.index[1:], axis="index")
+        .to_html()
+    )
+    expected_styles = dedent(
+        """\
+        <style type="text/css">
+        #T__level0_row0, #T__level1_row0 {
+          color: blue;
+        }
+        </style>
+        """
+    )
+    assert expected_styles in result
+
+
+def test_include_css_style_rules_only_for_visible_column_labels(styler_mi):
+    # GH 43619
+    result = (
+        styler_mi.set_uuid("")
+        .map_index(lambda v: "color: blue;", axis="columns")
+        .hide(styler_mi.data.columns[1:], axis="columns")
+        .hide(styler_mi.data.index, axis="index")
+        .to_html()
+    )
+    expected_styles = dedent(
+        """\
+        <style type="text/css">
+        #T__level0_col0, #T__level1_col0 {
+          color: blue;
+        }
+        </style>
+        """
+    )
+    assert expected_styles in result
+
+
+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(level=1, axis=0).hide(level=0, axis=1)
+    styler.hide([("j0", "i1", "j2")], axis=0)
+    styler.hide([("c0", "d1", "d2")], axis=1)
+    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
+
+
+def test_hiding_index_columns_multiindex_trimming():
+    # gh 44272
+    df = DataFrame(np.arange(64).reshape(8, 8))
+    df.columns = MultiIndex.from_product([[0, 1, 2, 3], [0, 1]])
+    df.index = MultiIndex.from_product([[0, 1, 2, 3], [0, 1]])
+    df.index.names, df.columns.names = ["a", "b"], ["c", "d"]
+    styler = Styler(df, cell_ids=False, uuid_len=0)
+    styler.hide([(0, 0), (0, 1), (1, 0)], axis=1).hide([(0, 0), (0, 1), (1, 0)], axis=0)
+    with option_context("styler.render.max_rows", 4, "styler.render.max_columns", 4):
+        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 level0" >c</th>
+          <th class="col_heading level0 col3" >1</th>
+          <th class="col_heading level0 col4" colspan="2">2</th>
+          <th class="col_heading level0 col6" >3</th>
+        </tr>
+        <tr>
+          <th class="blank" >&nbsp;</th>
+          <th class="index_name level1" >d</th>
+          <th class="col_heading level1 col3" >1</th>
+          <th class="col_heading level1 col4" >0</th>
+          <th class="col_heading level1 col5" >1</th>
+          <th class="col_heading level1 col6" >0</th>
+          <th class="col_heading level1 col_trim" >...</th>
+        </tr>
+        <tr>
+          <th class="index_name level0" >a</th>
+          <th class="index_name level1" >b</th>
+          <th class="blank col3" >&nbsp;</th>
+          <th class="blank col4" >&nbsp;</th>
+          <th class="blank col5" >&nbsp;</th>
+          <th class="blank col6" >&nbsp;</th>
+          <th class="blank col7 col_trim" >&nbsp;</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <th class="row_heading level0 row3" >1</th>
+          <th class="row_heading level1 row3" >1</th>
+          <td class="data row3 col3" >27</td>
+          <td class="data row3 col4" >28</td>
+          <td class="data row3 col5" >29</td>
+          <td class="data row3 col6" >30</td>
+          <td class="data row3 col_trim" >...</td>
+        </tr>
+        <tr>
+          <th class="row_heading level0 row4" rowspan="2">2</th>
+          <th class="row_heading level1 row4" >0</th>
+          <td class="data row4 col3" >35</td>
+          <td class="data row4 col4" >36</td>
+          <td class="data row4 col5" >37</td>
+          <td class="data row4 col6" >38</td>
+          <td class="data row4 col_trim" >...</td>
+        </tr>
+        <tr>
+          <th class="row_heading level1 row5" >1</th>
+          <td class="data row5 col3" >43</td>
+          <td class="data row5 col4" >44</td>
+          <td class="data row5 col5" >45</td>
+          <td class="data row5 col6" >46</td>
+          <td class="data row5 col_trim" >...</td>
+        </tr>
+        <tr>
+          <th class="row_heading level0 row6" >3</th>
+          <th class="row_heading level1 row6" >0</th>
+          <td class="data row6 col3" >51</td>
+          <td class="data row6 col4" >52</td>
+          <td class="data row6 col5" >53</td>
+          <td class="data row6 col6" >54</td>
+          <td class="data row6 col_trim" >...</td>
+        </tr>
+        <tr>
+          <th class="row_heading level0 row_trim" >...</th>
+          <th class="row_heading level1 row_trim" >...</th>
+          <td class="data col3 row_trim" >...</td>
+          <td class="data col4 row_trim" >...</td>
+          <td class="data col5 row_trim" >...</td>
+          <td class="data col6 row_trim" >...</td>
+          <td class="data row_trim col_trim" >...</td>
+        </tr>
+      </tbody>
+    </table>
+    """
+    )
+
+    assert result == expected
+
+
+@pytest.mark.parametrize("type", ["data", "index"])
+@pytest.mark.parametrize(
+    "text, exp, found",
+    [
+        ("no link, just text", False, ""),
+        ("subdomain not www: sub.web.com", False, ""),
+        ("www subdomain: www.web.com other", True, "www.web.com"),
+        ("scheme full structure: http://www.web.com", True, "http://www.web.com"),
+        ("scheme no top-level: http://www.web", True, "http://www.web"),
+        ("no scheme, no top-level: www.web", False, "www.web"),
+        ("https scheme: https://www.web.com", True, "https://www.web.com"),
+        ("ftp scheme: ftp://www.web", True, "ftp://www.web"),
+        ("ftps scheme: ftps://www.web", True, "ftps://www.web"),
+        ("subdirectories: www.web.com/directory", True, "www.web.com/directory"),
+        ("Multiple domains: www.1.2.3.4", True, "www.1.2.3.4"),
+        ("with port: http://web.com:80", True, "http://web.com:80"),
+        (
+            "full net_loc scheme: http://user:[email protected]",
+            True,
+            "http://user:[email protected]",
+        ),
+        (
+            "with valid special chars: http://web.com/,.':;~!@#$*()[]",
+            True,
+            "http://web.com/,.':;~!@#$*()[]",
+        ),
+    ],
+)
+def test_rendered_links(type, text, exp, found):
+    if type == "data":
+        df = DataFrame([text])
+        styler = df.style.format(hyperlinks="html")
+    else:
+        df = DataFrame([0], index=[text])
+        styler = df.style.format_index(hyperlinks="html")
+
+    rendered = f'<a href="{found}" target="_blank">{found}</a>'
+    result = styler.to_html()
+    assert (rendered in result) is exp
+    assert (text in result) is not exp  # test conversion done when expected and not
+
+
+def test_multiple_rendered_links():
+    links = ("www.a.b", "http://a.c", "https://a.d", "ftp://a.e")
+    # pylint: disable-next=consider-using-f-string
+    df = DataFrame(["text {} {} text {} {}".format(*links)])
+    result = df.style.format(hyperlinks="html").to_html()
+    href = '<a href="{0}" target="_blank">{0}</a>'
+    for link in links:
+        assert href.format(link) in result
+    assert href.format("text") not in result
+
+
+def test_concat(styler):
+    other = styler.data.agg(["mean"]).style
+    styler.concat(other).set_uuid("X")
+    result = styler.to_html()
+    fp = "foot0_"
+    expected = dedent(
+        f"""\
+    <tr>
+      <th id="T_X_level0_row1" class="row_heading level0 row1" >b</th>
+      <td id="T_X_row1_col0" class="data row1 col0" >2.690000</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp}row0" class="{fp}row_heading level0 {fp}row0" >mean</th>
+      <td id="T_X_{fp}row0_col0" class="{fp}data {fp}row0 col0" >2.650000</td>
+    </tr>
+  </tbody>
+</table>
+    """
+    )
+    assert expected in result
+
+
+def test_concat_recursion(styler):
+    df = styler.data
+    styler1 = styler
+    styler2 = Styler(df.agg(["mean"]), precision=3)
+    styler3 = Styler(df.agg(["mean"]), precision=4)
+    styler1.concat(styler2.concat(styler3)).set_uuid("X")
+    result = styler.to_html()
+    # notice that the second concat (last <tr> of the output html),
+    # there are two `foot_` in the id and class
+    fp1 = "foot0_"
+    fp2 = "foot0_foot0_"
+    expected = dedent(
+        f"""\
+    <tr>
+      <th id="T_X_level0_row1" class="row_heading level0 row1" >b</th>
+      <td id="T_X_row1_col0" class="data row1 col0" >2.690000</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp1}row0" class="{fp1}row_heading level0 {fp1}row0" >mean</th>
+      <td id="T_X_{fp1}row0_col0" class="{fp1}data {fp1}row0 col0" >2.650</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp2}row0" class="{fp2}row_heading level0 {fp2}row0" >mean</th>
+      <td id="T_X_{fp2}row0_col0" class="{fp2}data {fp2}row0 col0" >2.6500</td>
+    </tr>
+  </tbody>
+</table>
+    """
+    )
+    assert expected in result
+
+
+def test_concat_chain(styler):
+    df = styler.data
+    styler1 = styler
+    styler2 = Styler(df.agg(["mean"]), precision=3)
+    styler3 = Styler(df.agg(["mean"]), precision=4)
+    styler1.concat(styler2).concat(styler3).set_uuid("X")
+    result = styler.to_html()
+    fp1 = "foot0_"
+    fp2 = "foot1_"
+    expected = dedent(
+        f"""\
+    <tr>
+      <th id="T_X_level0_row1" class="row_heading level0 row1" >b</th>
+      <td id="T_X_row1_col0" class="data row1 col0" >2.690000</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp1}row0" class="{fp1}row_heading level0 {fp1}row0" >mean</th>
+      <td id="T_X_{fp1}row0_col0" class="{fp1}data {fp1}row0 col0" >2.650</td>
+    </tr>
+    <tr>
+      <th id="T_X_level0_{fp2}row0" class="{fp2}row_heading level0 {fp2}row0" >mean</th>
+      <td id="T_X_{fp2}row0_col0" class="{fp2}data {fp2}row0 col0" >2.6500</td>
+    </tr>
+  </tbody>
+</table>
+    """
+    )
+    assert expected in result
+
+
+def test_concat_combined():
+    def html_lines(foot_prefix: str):
+        assert foot_prefix.endswith("_") or foot_prefix == ""
+        fp = foot_prefix
+        return indent(
+            dedent(
+                f"""\
+        <tr>
+          <th id="T_X_level0_{fp}row0" class="{fp}row_heading level0 {fp}row0" >a</th>
+          <td id="T_X_{fp}row0_col0" class="{fp}data {fp}row0 col0" >2.610000</td>
+        </tr>
+        <tr>
+          <th id="T_X_level0_{fp}row1" class="{fp}row_heading level0 {fp}row1" >b</th>
+          <td id="T_X_{fp}row1_col0" class="{fp}data {fp}row1 col0" >2.690000</td>
+        </tr>
+        """
+            ),
+            prefix=" " * 4,
+        )
+
+    df = DataFrame([[2.61], [2.69]], index=["a", "b"], columns=["A"])
+    s1 = df.style.highlight_max(color="red")
+    s2 = df.style.highlight_max(color="green")
+    s3 = df.style.highlight_max(color="blue")
+    s4 = df.style.highlight_max(color="yellow")
+
+    result = s1.concat(s2).concat(s3.concat(s4)).set_uuid("X").to_html()
+    expected_css = dedent(
+        """\
+        <style type="text/css">
+        #T_X_row1_col0 {
+          background-color: red;
+        }
+        #T_X_foot0_row1_col0 {
+          background-color: green;
+        }
+        #T_X_foot1_row1_col0 {
+          background-color: blue;
+        }
+        #T_X_foot1_foot0_row1_col0 {
+          background-color: yellow;
+        }
+        </style>
+        """
+    )
+    expected_table = (
+        dedent(
+            """\
+            <table id="T_X">
+              <thead>
+                <tr>
+                  <th class="blank level0" >&nbsp;</th>
+                  <th id="T_X_level0_col0" class="col_heading level0 col0" >A</th>
+                </tr>
+              </thead>
+              <tbody>
+            """
+        )
+        + html_lines("")
+        + html_lines("foot0_")
+        + html_lines("foot1_")
+        + html_lines("foot1_foot0_")
+        + dedent(
+            """\
+              </tbody>
+            </table>
+            """
+        )
+    )
+    assert expected_css + expected_table == result
+
+
+def test_to_html_na_rep_non_scalar_data(datapath):
+    # GH47103
+    df = DataFrame([{"a": 1, "b": [1, 2, 3], "c": np.nan}])
+    result = df.style.format(na_rep="-").to_html(table_uuid="test")
+    expected = """\
+<style type="text/css">
+</style>
+<table id="T_test">
+  <thead>
+    <tr>
+      <th class="blank level0" >&nbsp;</th>
+      <th id="T_test_level0_col0" class="col_heading level0 col0" >a</th>
+      <th id="T_test_level0_col1" class="col_heading level0 col1" >b</th>
+      <th id="T_test_level0_col2" class="col_heading level0 col2" >c</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th id="T_test_level0_row0" class="row_heading level0 row0" >0</th>
+      <td id="T_test_row0_col0" class="data row0 col0" >1</td>
+      <td id="T_test_row0_col1" class="data row0 col1" >[1, 2, 3]</td>
+      <td id="T_test_row0_col2" class="data row0 col2" >-</td>
+    </tr>
+  </tbody>
+</table>
+"""
+    assert result == expected

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_matplotlib.py

@@ -0,0 +1,335 @@
+import gc
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    IndexSlice,
+    Series,
+)
+
+pytest.importorskip("matplotlib")
+pytest.importorskip("jinja2")
+
+import matplotlib as mpl
+
+from pandas.io.formats.style import Styler
+
+
+@pytest.fixture(autouse=True)
+def mpl_cleanup():
+    # matplotlib/testing/decorators.py#L24
+    # 1) Resets units registry
+    # 2) Resets rc_context
+    # 3) Closes all figures
+    mpl = pytest.importorskip("matplotlib")
+    mpl_units = pytest.importorskip("matplotlib.units")
+    plt = pytest.importorskip("matplotlib.pyplot")
+    orig_units_registry = mpl_units.registry.copy()
+    with mpl.rc_context():
+        mpl.use("template")
+        yield
+    mpl_units.registry.clear()
+    mpl_units.registry.update(orig_units_registry)
+    plt.close("all")
+    # https://matplotlib.org/stable/users/prev_whats_new/whats_new_3.6.0.html#garbage-collection-is-no-longer-run-on-figure-close  # noqa: E501
+    gc.collect(1)
+
+
+@pytest.fixture
+def df():
+    return DataFrame([[1, 2], [2, 4]], columns=["A", "B"])
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0)
+
+
+@pytest.fixture
+def df_blank():
+    return DataFrame([[0, 0], [0, 0]], columns=["A", "B"], index=["X", "Y"])
+
+
+@pytest.fixture
+def styler_blank(df_blank):
+    return Styler(df_blank, uuid_len=0)
+
+
+@pytest.mark.parametrize("f", ["background_gradient", "text_gradient"])
+def test_function_gradient(styler, f):
+    for c_map in [None, "YlOrRd"]:
+        result = getattr(styler, f)(cmap=c_map)._compute().ctx
+        assert all("#" in x[0][1] for x in result.values())
+        assert result[(0, 0)] == result[(0, 1)]
+        assert result[(1, 0)] == result[(1, 1)]
+
+
+@pytest.mark.parametrize("f", ["background_gradient", "text_gradient"])
+def test_background_gradient_color(styler, f):
+    result = getattr(styler, f)(subset=IndexSlice[1, "A"])._compute().ctx
+    if f == "background_gradient":
+        assert result[(1, 0)] == [("background-color", "#fff7fb"), ("color", "#000000")]
+    elif f == "text_gradient":
+        assert result[(1, 0)] == [("color", "#fff7fb")]
+
+
+@pytest.mark.parametrize(
+    "axis, expected",
+    [
+        (0, ["low", "low", "high", "high"]),
+        (1, ["low", "high", "low", "high"]),
+        (None, ["low", "mid", "mid", "high"]),
+    ],
+)
+@pytest.mark.parametrize("f", ["background_gradient", "text_gradient"])
+def test_background_gradient_axis(styler, axis, expected, f):
+    if f == "background_gradient":
+        colors = {
+            "low": [("background-color", "#f7fbff"), ("color", "#000000")],
+            "mid": [("background-color", "#abd0e6"), ("color", "#000000")],
+            "high": [("background-color", "#08306b"), ("color", "#f1f1f1")],
+        }
+    elif f == "text_gradient":
+        colors = {
+            "low": [("color", "#f7fbff")],
+            "mid": [("color", "#abd0e6")],
+            "high": [("color", "#08306b")],
+        }
+    result = getattr(styler, f)(cmap="Blues", axis=axis)._compute().ctx
+    for i, cell in enumerate([(0, 0), (0, 1), (1, 0), (1, 1)]):
+        assert result[cell] == colors[expected[i]]
+
+
+@pytest.mark.parametrize(
+    "cmap, expected",
+    [
+        (
+            "PuBu",
+            {
+                (4, 5): [("background-color", "#86b0d3"), ("color", "#000000")],
+                (4, 6): [("background-color", "#83afd3"), ("color", "#f1f1f1")],
+            },
+        ),
+        (
+            "YlOrRd",
+            {
+                (4, 8): [("background-color", "#fd913e"), ("color", "#000000")],
+                (4, 9): [("background-color", "#fd8f3d"), ("color", "#f1f1f1")],
+            },
+        ),
+        (
+            None,
+            {
+                (7, 0): [("background-color", "#48c16e"), ("color", "#f1f1f1")],
+                (7, 1): [("background-color", "#4cc26c"), ("color", "#000000")],
+            },
+        ),
+    ],
+)
+def test_text_color_threshold(cmap, expected):
+    # GH 39888
+    df = DataFrame(np.arange(100).reshape(10, 10))
+    result = df.style.background_gradient(cmap=cmap, axis=None)._compute().ctx
+    for k in expected.keys():
+        assert result[k] == expected[k]
+
+
+def test_background_gradient_vmin_vmax():
+    # GH 12145
+    df = DataFrame(range(5))
+    ctx = df.style.background_gradient(vmin=1, vmax=3)._compute().ctx
+    assert ctx[(0, 0)] == ctx[(1, 0)]
+    assert ctx[(4, 0)] == ctx[(3, 0)]
+
+
+def test_background_gradient_int64():
+    # GH 28869
+    df1 = Series(range(3)).to_frame()
+    df2 = Series(range(3), dtype="Int64").to_frame()
+    ctx1 = df1.style.background_gradient()._compute().ctx
+    ctx2 = df2.style.background_gradient()._compute().ctx
+    assert ctx2[(0, 0)] == ctx1[(0, 0)]
+    assert ctx2[(1, 0)] == ctx1[(1, 0)]
+    assert ctx2[(2, 0)] == ctx1[(2, 0)]
+
+
+@pytest.mark.parametrize(
+    "axis, gmap, expected",
+    [
+        (
+            0,
+            [1, 2],
+            {
+                (0, 0): [("background-color", "#fff7fb"), ("color", "#000000")],
+                (1, 0): [("background-color", "#023858"), ("color", "#f1f1f1")],
+                (0, 1): [("background-color", "#fff7fb"), ("color", "#000000")],
+                (1, 1): [("background-color", "#023858"), ("color", "#f1f1f1")],
+            },
+        ),
+        (
+            1,
+            [1, 2],
+            {
+                (0, 0): [("background-color", "#fff7fb"), ("color", "#000000")],
+                (1, 0): [("background-color", "#fff7fb"), ("color", "#000000")],
+                (0, 1): [("background-color", "#023858"), ("color", "#f1f1f1")],
+                (1, 1): [("background-color", "#023858"), ("color", "#f1f1f1")],
+            },
+        ),
+        (
+            None,
+            np.array([[2, 1], [1, 2]]),
+            {
+                (0, 0): [("background-color", "#023858"), ("color", "#f1f1f1")],
+                (1, 0): [("background-color", "#fff7fb"), ("color", "#000000")],
+                (0, 1): [("background-color", "#fff7fb"), ("color", "#000000")],
+                (1, 1): [("background-color", "#023858"), ("color", "#f1f1f1")],
+            },
+        ),
+    ],
+)
+def test_background_gradient_gmap_array(styler_blank, axis, gmap, expected):
+    # tests when gmap is given as a sequence and converted to ndarray
+    result = styler_blank.background_gradient(axis=axis, gmap=gmap)._compute().ctx
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "gmap, axis", [([1, 2, 3], 0), ([1, 2], 1), (np.array([[1, 2], [1, 2]]), None)]
+)
+def test_background_gradient_gmap_array_raises(gmap, axis):
+    # test when gmap as converted ndarray is bad shape
+    df = DataFrame([[0, 0, 0], [0, 0, 0]])
+    msg = "supplied 'gmap' is not correct shape"
+    with pytest.raises(ValueError, match=msg):
+        df.style.background_gradient(gmap=gmap, axis=axis)._compute()
+
+
+@pytest.mark.parametrize(
+    "gmap",
+    [
+        DataFrame(  # reverse the columns
+            [[2, 1], [1, 2]], columns=["B", "A"], index=["X", "Y"]
+        ),
+        DataFrame(  # reverse the index
+            [[2, 1], [1, 2]], columns=["A", "B"], index=["Y", "X"]
+        ),
+        DataFrame(  # reverse the index and columns
+            [[1, 2], [2, 1]], columns=["B", "A"], index=["Y", "X"]
+        ),
+        DataFrame(  # add unnecessary columns
+            [[1, 2, 3], [2, 1, 3]], columns=["A", "B", "C"], index=["X", "Y"]
+        ),
+        DataFrame(  # add unnecessary index
+            [[1, 2], [2, 1], [3, 3]], columns=["A", "B"], index=["X", "Y", "Z"]
+        ),
+    ],
+)
+@pytest.mark.parametrize(
+    "subset, exp_gmap",  # exp_gmap is underlying map DataFrame should conform to
+    [
+        (None, [[1, 2], [2, 1]]),
+        (["A"], [[1], [2]]),  # slice only column "A" in data and gmap
+        (["B", "A"], [[2, 1], [1, 2]]),  # reverse the columns in data
+        (IndexSlice["X", :], [[1, 2]]),  # slice only index "X" in data and gmap
+        (IndexSlice[["Y", "X"], :], [[2, 1], [1, 2]]),  # reverse the index in data
+    ],
+)
+def test_background_gradient_gmap_dataframe_align(styler_blank, gmap, subset, exp_gmap):
+    # test gmap given as DataFrame that it aligns to the data including subset
+    expected = styler_blank.background_gradient(axis=None, gmap=exp_gmap, subset=subset)
+    result = styler_blank.background_gradient(axis=None, gmap=gmap, subset=subset)
+    assert expected._compute().ctx == result._compute().ctx
+
+
+@pytest.mark.parametrize(
+    "gmap, axis, exp_gmap",
+    [
+        (Series([2, 1], index=["Y", "X"]), 0, [[1, 1], [2, 2]]),  # revrse the index
+        (Series([2, 1], index=["B", "A"]), 1, [[1, 2], [1, 2]]),  # revrse the cols
+        (Series([1, 2, 3], index=["X", "Y", "Z"]), 0, [[1, 1], [2, 2]]),  # add idx
+        (Series([1, 2, 3], index=["A", "B", "C"]), 1, [[1, 2], [1, 2]]),  # add col
+    ],
+)
+def test_background_gradient_gmap_series_align(styler_blank, gmap, axis, exp_gmap):
+    # test gmap given as Series that it aligns to the data including subset
+    expected = styler_blank.background_gradient(axis=None, gmap=exp_gmap)._compute()
+    result = styler_blank.background_gradient(axis=axis, gmap=gmap)._compute()
+    assert expected.ctx == result.ctx
+
+
+@pytest.mark.parametrize(
+    "gmap, axis",
+    [
+        (DataFrame([[1, 2], [2, 1]], columns=["A", "B"], index=["X", "Y"]), 1),
+        (DataFrame([[1, 2], [2, 1]], columns=["A", "B"], index=["X", "Y"]), 0),
+    ],
+)
+def test_background_gradient_gmap_wrong_dataframe(styler_blank, gmap, axis):
+    # test giving a gmap in DataFrame but with wrong axis
+    msg = "'gmap' is a DataFrame but underlying data for operations is a Series"
+    with pytest.raises(ValueError, match=msg):
+        styler_blank.background_gradient(gmap=gmap, axis=axis)._compute()
+
+
+def test_background_gradient_gmap_wrong_series(styler_blank):
+    # test giving a gmap in Series form but with wrong axis
+    msg = "'gmap' is a Series but underlying data for operations is a DataFrame"
+    gmap = Series([1, 2], index=["X", "Y"])
+    with pytest.raises(ValueError, match=msg):
+        styler_blank.background_gradient(gmap=gmap, axis=None)._compute()
+
+
+def test_background_gradient_nullable_dtypes():
+    # GH 50712
+    df1 = DataFrame([[1], [0], [np.nan]], dtype=float)
+    df2 = DataFrame([[1], [0], [None]], dtype="Int64")
+
+    ctx1 = df1.style.background_gradient()._compute().ctx
+    ctx2 = df2.style.background_gradient()._compute().ctx
+    assert ctx1 == ctx2
+
+
+@pytest.mark.parametrize(
+    "cmap",
+    ["PuBu", mpl.colormaps["PuBu"]],
+)
+def test_bar_colormap(cmap):
+    data = DataFrame([[1, 2], [3, 4]])
+    ctx = data.style.bar(cmap=cmap, axis=None)._compute().ctx
+    pubu_colors = {
+        (0, 0): "#d0d1e6",
+        (1, 0): "#056faf",
+        (0, 1): "#73a9cf",
+        (1, 1): "#023858",
+    }
+    for k, v in pubu_colors.items():
+        assert v in ctx[k][1][1]
+
+
+def test_bar_color_raises(df):
+    msg = "`color` must be string or list or tuple of 2 strings"
+    with pytest.raises(ValueError, match=msg):
+        df.style.bar(color={"a", "b"}).to_html()
+    with pytest.raises(ValueError, match=msg):
+        df.style.bar(color=["a", "b", "c"]).to_html()
+
+    msg = "`color` and `cmap` cannot both be given"
+    with pytest.raises(ValueError, match=msg):
+        df.style.bar(color="something", cmap="something else").to_html()
+
+
+@pytest.mark.parametrize(
+    "plot_method",
+    ["scatter", "hexbin"],
+)
+def test_pass_colormap_instance(df, plot_method):
+    # https://github.com/pandas-dev/pandas/issues/49374
+    cmap = mpl.colors.ListedColormap([[1, 1, 1], [0, 0, 0]])
+    df["c"] = df.A + df.B
+    kwargs = {"x": "A", "y": "B", "c": "c", "colormap": cmap}
+    if plot_method == "hexbin":
+        kwargs["C"] = kwargs.pop("c")
+    getattr(df.plot, plot_method)(**kwargs)

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_non_unique.py

@@ -0,0 +1,140 @@
+from textwrap import dedent
+
+import pytest
+
+from pandas import (
+    DataFrame,
+    IndexSlice,
+)
+
+pytest.importorskip("jinja2")
+
+from pandas.io.formats.style import Styler
+
+
+@pytest.fixture
+def df():
+    return DataFrame(
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+        index=["i", "j", "j"],
+        columns=["c", "d", "d"],
+        dtype=float,
+    )
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0)
+
+
+def test_format_non_unique(df):
+    # GH 41269
+
+    # test dict
+    html = df.style.format({"d": "{:.1f}"}).to_html()
+    for val in ["1.000000<", "4.000000<", "7.000000<"]:
+        assert val in html
+    for val in ["2.0<", "3.0<", "5.0<", "6.0<", "8.0<", "9.0<"]:
+        assert val in html
+
+    # test subset
+    html = df.style.format(precision=1, subset=IndexSlice["j", "d"]).to_html()
+    for val in ["1.000000<", "4.000000<", "7.000000<", "2.000000<", "3.000000<"]:
+        assert val in html
+    for val in ["5.0<", "6.0<", "8.0<", "9.0<"]:
+        assert val in html
+
+
+@pytest.mark.parametrize("func", ["apply", "map"])
+def test_apply_map_non_unique_raises(df, func):
+    # GH 41269
+    if func == "apply":
+        op = lambda s: ["color: red;"] * len(s)
+    else:
+        op = lambda v: "color: red;"
+
+    with pytest.raises(KeyError, match="`Styler.apply` and `.map` are not"):
+        getattr(df.style, func)(op)._compute()
+
+
+def test_table_styles_dict_non_unique_index(styler):
+    styles = styler.set_table_styles(
+        {"j": [{"selector": "td", "props": "a: v;"}]}, axis=1
+    ).table_styles
+    assert styles == [
+        {"selector": "td.row1", "props": [("a", "v")]},
+        {"selector": "td.row2", "props": [("a", "v")]},
+    ]
+
+
+def test_table_styles_dict_non_unique_columns(styler):
+    styles = styler.set_table_styles(
+        {"d": [{"selector": "td", "props": "a: v;"}]}, axis=0
+    ).table_styles
+    assert styles == [
+        {"selector": "td.col1", "props": [("a", "v")]},
+        {"selector": "td.col2", "props": [("a", "v")]},
+    ]
+
+
+def test_tooltips_non_unique_raises(styler):
+    # ttips has unique keys
+    ttips = DataFrame([["1", "2"], ["3", "4"]], columns=["c", "d"], index=["a", "b"])
+    styler.set_tooltips(ttips=ttips)  # OK
+
+    # ttips has non-unique columns
+    ttips = DataFrame([["1", "2"], ["3", "4"]], columns=["c", "c"], index=["a", "b"])
+    with pytest.raises(KeyError, match="Tooltips render only if `ttips` has unique"):
+        styler.set_tooltips(ttips=ttips)
+
+    # ttips has non-unique index
+    ttips = DataFrame([["1", "2"], ["3", "4"]], columns=["c", "d"], index=["a", "a"])
+    with pytest.raises(KeyError, match="Tooltips render only if `ttips` has unique"):
+        styler.set_tooltips(ttips=ttips)
+
+
+def test_set_td_classes_non_unique_raises(styler):
+    # classes has unique keys
+    classes = DataFrame([["1", "2"], ["3", "4"]], columns=["c", "d"], index=["a", "b"])
+    styler.set_td_classes(classes=classes)  # OK
+
+    # classes has non-unique columns
+    classes = DataFrame([["1", "2"], ["3", "4"]], columns=["c", "c"], index=["a", "b"])
+    with pytest.raises(KeyError, match="Classes render only if `classes` has unique"):
+        styler.set_td_classes(classes=classes)
+
+    # classes has non-unique index
+    classes = DataFrame([["1", "2"], ["3", "4"]], columns=["c", "d"], index=["a", "a"])
+    with pytest.raises(KeyError, match="Classes render only if `classes` has unique"):
+        styler.set_td_classes(classes=classes)
+
+
+def test_hide_columns_non_unique(styler):
+    ctx = styler.hide(["d"], axis="columns")._translate(True, True)
+
+    assert ctx["head"][0][1]["display_value"] == "c"
+    assert ctx["head"][0][1]["is_visible"] is True
+
+    assert ctx["head"][0][2]["display_value"] == "d"
+    assert ctx["head"][0][2]["is_visible"] is False
+
+    assert ctx["head"][0][3]["display_value"] == "d"
+    assert ctx["head"][0][3]["is_visible"] is False
+
+    assert ctx["body"][0][1]["is_visible"] is True
+    assert ctx["body"][0][2]["is_visible"] is False
+    assert ctx["body"][0][3]["is_visible"] is False
+
+
+def test_latex_non_unique(styler):
+    result = styler.to_latex()
+    assert result == dedent(
+        """\
+        \\begin{tabular}{lrrr}
+         & c & d & d \\\\
+        i & 1.000000 & 2.000000 & 3.000000 \\\\
+        j & 4.000000 & 5.000000 & 6.000000 \\\\
+        j & 7.000000 & 8.000000 & 9.000000 \\\\
+        \\end{tabular}
+    """
+    )

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_style.py

@@ -0,0 +1,1588 @@
+import contextlib
+import copy
+import re
+from textwrap import dedent
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    IndexSlice,
+    MultiIndex,
+    Series,
+    option_context,
+)
+import pandas._testing as tm
+
+jinja2 = pytest.importorskip("jinja2")
+from pandas.io.formats.style import (  # isort:skip
+    Styler,
+)
+from pandas.io.formats.style_render import (
+    _get_level_lengths,
+    _get_trimming_maximums,
+    maybe_convert_css_to_tuples,
+    non_reducing_slice,
+)
+
+
+@pytest.fixture
+def mi_df():
+    return DataFrame(
+        [[1, 2], [3, 4]],
+        index=MultiIndex.from_product([["i0"], ["i1_a", "i1_b"]]),
+        columns=MultiIndex.from_product([["c0"], ["c1_a", "c1_b"]]),
+        dtype=int,
+    )
+
+
+@pytest.fixture
+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 = mi_styler._copy(deepcopy=True)
+    mi_styler.css = {**mi_styler.css, "row": "ROW", "col": "COL"}
+    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(axis="columns")
+    mi_styler.hide([("c0", "c1_a")], axis="columns", names=True)
+    mi_styler.hide(axis="index")
+    mi_styler.hide([("i0", "i1_a")], axis="index", names=True)
+    mi_styler.set_table_attributes('class="box"')
+    other = mi_styler.data.agg(["mean"])
+    other.index = MultiIndex.from_product([[""], other.index])
+    mi_styler.concat(other.style)
+    mi_styler.format(na_rep="MISSING", precision=3)
+    mi_styler.format_index(precision=2, axis=0)
+    mi_styler.format_index(precision=4, axis=1)
+    mi_styler.highlight_max(axis=None)
+    mi_styler.map_index(lambda x: "color: white;", axis=0)
+    mi_styler.map_index(lambda x: "color: black;", axis=1)
+    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.fixture
+def blank_value():
+    return " "
+
+
+@pytest.fixture
+def df():
+    df = DataFrame({"A": [0, 1], "B": np.random.default_rng(2).standard_normal(2)})
+    return df
+
+
+@pytest.fixture
+def styler(df):
+    df = DataFrame({"A": [0, 1], "B": np.random.default_rng(2).standard_normal(2)})
+    return Styler(df)
+
+
+@pytest.mark.parametrize(
+    "sparse_columns, exp_cols",
+    [
+        (
+            True,
+            [
+                {"is_visible": True, "attributes": 'colspan="2"', "value": "c0"},
+                {"is_visible": False, "attributes": "", "value": "c0"},
+            ],
+        ),
+        (
+            False,
+            [
+                {"is_visible": True, "attributes": "", "value": "c0"},
+                {"is_visible": True, "attributes": "", "value": "c0"},
+            ],
+        ),
+    ],
+)
+def test_mi_styler_sparsify_columns(mi_styler, sparse_columns, exp_cols):
+    exp_l1_c0 = {"is_visible": True, "attributes": "", "display_value": "c1_a"}
+    exp_l1_c1 = {"is_visible": True, "attributes": "", "display_value": "c1_b"}
+
+    ctx = mi_styler._translate(True, sparse_columns)
+
+    assert exp_cols[0].items() <= ctx["head"][0][2].items()
+    assert exp_cols[1].items() <= ctx["head"][0][3].items()
+    assert exp_l1_c0.items() <= ctx["head"][1][2].items()
+    assert exp_l1_c1.items() <= ctx["head"][1][3].items()
+
+
+@pytest.mark.parametrize(
+    "sparse_index, exp_rows",
+    [
+        (
+            True,
+            [
+                {"is_visible": True, "attributes": 'rowspan="2"', "value": "i0"},
+                {"is_visible": False, "attributes": "", "value": "i0"},
+            ],
+        ),
+        (
+            False,
+            [
+                {"is_visible": True, "attributes": "", "value": "i0"},
+                {"is_visible": True, "attributes": "", "value": "i0"},
+            ],
+        ),
+    ],
+)
+def test_mi_styler_sparsify_index(mi_styler, sparse_index, exp_rows):
+    exp_l1_r0 = {"is_visible": True, "attributes": "", "display_value": "i1_a"}
+    exp_l1_r1 = {"is_visible": True, "attributes": "", "display_value": "i1_b"}
+
+    ctx = mi_styler._translate(sparse_index, True)
+
+    assert exp_rows[0].items() <= ctx["body"][0][0].items()
+    assert exp_rows[1].items() <= ctx["body"][1][0].items()
+    assert exp_l1_r0.items() <= ctx["body"][0][1].items()
+    assert exp_l1_r1.items() <= ctx["body"][1][1].items()
+
+
+def test_mi_styler_sparsify_options(mi_styler):
+    with option_context("styler.sparse.index", False):
+        html1 = mi_styler.to_html()
+    with option_context("styler.sparse.index", True):
+        html2 = mi_styler.to_html()
+
+    assert html1 != html2
+
+    with option_context("styler.sparse.columns", False):
+        html1 = mi_styler.to_html()
+    with option_context("styler.sparse.columns", True):
+        html2 = mi_styler.to_html()
+
+    assert html1 != html2
+
+
+@pytest.mark.parametrize(
+    "rn, cn, max_els, max_rows, max_cols, exp_rn, exp_cn",
+    [
+        (100, 100, 100, None, None, 12, 6),  # reduce to (12, 6) < 100 elements
+        (1000, 3, 750, None, None, 250, 3),  # dynamically reduce rows to 250, keep cols
+        (4, 1000, 500, None, None, 4, 125),  # dynamically reduce cols to 125, keep rows
+        (1000, 3, 750, 10, None, 10, 3),  # overwrite above dynamics with max_row
+        (4, 1000, 500, None, 5, 4, 5),  # overwrite above dynamics with max_col
+        (100, 100, 700, 50, 50, 25, 25),  # rows cols below given maxes so < 700 elmts
+    ],
+)
+def test_trimming_maximum(rn, cn, max_els, max_rows, max_cols, exp_rn, exp_cn):
+    rn, cn = _get_trimming_maximums(
+        rn, cn, max_els, max_rows, max_cols, scaling_factor=0.5
+    )
+    assert (rn, cn) == (exp_rn, exp_cn)
+
+
+@pytest.mark.parametrize(
+    "option, val",
+    [
+        ("styler.render.max_elements", 6),
+        ("styler.render.max_rows", 3),
+    ],
+)
+def test_render_trimming_rows(option, val):
+    # test auto and specific trimming of rows
+    df = DataFrame(np.arange(120).reshape(60, 2))
+    with option_context(option, val):
+        ctx = df.style._translate(True, True)
+    assert len(ctx["head"][0]) == 3  # index + 2 data cols
+    assert len(ctx["body"]) == 4  # 3 data rows + trimming row
+    assert len(ctx["body"][0]) == 3  # index + 2 data cols
+
+
+@pytest.mark.parametrize(
+    "option, val",
+    [
+        ("styler.render.max_elements", 6),
+        ("styler.render.max_columns", 2),
+    ],
+)
+def test_render_trimming_cols(option, val):
+    # test auto and specific trimming of cols
+    df = DataFrame(np.arange(30).reshape(3, 10))
+    with option_context(option, val):
+        ctx = df.style._translate(True, True)
+    assert len(ctx["head"][0]) == 4  # index + 2 data cols + trimming col
+    assert len(ctx["body"]) == 3  # 3 data rows
+    assert len(ctx["body"][0]) == 4  # index + 2 data cols + trimming col
+
+
+def test_render_trimming_mi():
+    midx = MultiIndex.from_product([[1, 2], [1, 2, 3]])
+    df = DataFrame(np.arange(36).reshape(6, 6), columns=midx, index=midx)
+    with option_context("styler.render.max_elements", 4):
+        ctx = df.style._translate(True, True)
+
+    assert len(ctx["body"][0]) == 5  # 2 indexes + 2 data cols + trimming row
+    assert {"attributes": 'rowspan="2"'}.items() <= ctx["body"][0][0].items()
+    assert {"class": "data row0 col_trim"}.items() <= ctx["body"][0][4].items()
+    assert {"class": "data row_trim col_trim"}.items() <= ctx["body"][2][4].items()
+    assert len(ctx["body"]) == 3  # 2 data rows + trimming row
+
+
+def test_render_empty_mi():
+    # GH 43305
+    df = DataFrame(index=MultiIndex.from_product([["A"], [0, 1]], names=[None, "one"]))
+    expected = dedent(
+        """\
+    >
+      <thead>
+        <tr>
+          <th class="index_name level0" >&nbsp;</th>
+          <th class="index_name level1" >one</th>
+        </tr>
+      </thead>
+    """
+    )
+    assert expected in df.style.to_html()
+
+
+@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 = [
+        "cellstyle_map",  # render time vars..
+        "cellstyle_map_columns",
+        "cellstyle_map_index",
+        "template_latex",  # render templates are class level
+        "template_html",
+        "template_html_style",
+        "template_html_table",
+    ]
+    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",
+            "uuid",
+            "caption",
+            "cell_ids",
+            "hide_index_",
+            "hide_columns_",
+            "hide_index_names",
+            "hide_column_names",
+            "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))
+
+
+@pytest.mark.parametrize("deepcopy", [True, False])
+def test_inherited_copy(mi_styler, deepcopy):
+    # Ensure that the inherited class is preserved when a Styler object is copied.
+    # GH 52728
+    class CustomStyler(Styler):
+        pass
+
+    custom_styler = CustomStyler(mi_styler.data)
+    custom_styler_copy = (
+        copy.deepcopy(custom_styler) if deepcopy else copy.copy(custom_styler)
+    )
+    assert isinstance(custom_styler_copy, CustomStyler)
+
+
+def test_clear(mi_styler_comp):
+    # NOTE: if this test fails for new features then 'mi_styler_comp' should be updated
+    # to ensure proper testing of the 'copy', 'clear', 'export' methods with new feature
+    # GH 40675
+    styler = mi_styler_comp
+    styler._compute()  # execute applied methods
+
+    clean_copy = Styler(styler.data, uuid=styler.uuid)
+
+    excl = [
+        "data",
+        "index",
+        "columns",
+        "uuid",
+        "uuid_len",  # uuid is set to be the same on styler and clean_copy
+        "cell_ids",
+        "cellstyle_map",  # execution time only
+        "cellstyle_map_columns",  # execution time only
+        "cellstyle_map_index",  # execution time only
+        "template_latex",  # render templates are class level
+        "template_html",
+        "template_html_style",
+        "template_html_table",
+    ]
+    # tests vars are not same vals on obj and clean copy before clear (except for excl)
+    for attr in [a for a in styler.__dict__ if not (callable(a) or a in excl)]:
+        res = getattr(styler, attr) == getattr(clean_copy, attr)
+        if hasattr(res, "__iter__") and len(res) > 0:
+            assert not all(res)  # some element in iterable differs
+        elif hasattr(res, "__iter__") and len(res) == 0:
+            pass  # empty array
+        else:
+            assert not res  # explicit var differs
+
+    # test vars have same vales on obj and clean copy after clearing
+    styler.clear()
+    for attr in [a for a in styler.__dict__ if not callable(a)]:
+        res = getattr(styler, attr) == getattr(clean_copy, attr)
+        assert all(res) if hasattr(res, "__iter__") else res
+
+
+def test_export(mi_styler_comp, mi_styler):
+    exp_attrs = [
+        "_todo",
+        "hide_index_",
+        "hide_index_names",
+        "hide_columns_",
+        "hide_column_names",
+        "table_attributes",
+        "table_styles",
+        "css",
+    ]
+    for attr in exp_attrs:
+        check = getattr(mi_styler, attr) == getattr(mi_styler_comp, attr)
+        assert not (
+            all(check) if (hasattr(check, "__iter__") and len(check) > 0) else check
+        )
+
+    export = mi_styler_comp.export()
+    used = mi_styler.use(export)
+    for attr in exp_attrs:
+        check = getattr(used, attr) == getattr(mi_styler_comp, attr)
+        assert all(check) if (hasattr(check, "__iter__") and len(check) > 0) else check
+
+    used.to_html()
+
+
+def test_hide_raises(mi_styler):
+    msg = "`subset` and `level` cannot be passed simultaneously"
+    with pytest.raises(ValueError, match=msg):
+        mi_styler.hide(axis="index", subset="something", level="something else")
+
+    msg = "`level` must be of type `int`, `str` or list of such"
+    with pytest.raises(ValueError, match=msg):
+        mi_styler.hide(axis="index", level={"bad": 1, "type": 2})
+
+
+@pytest.mark.parametrize("level", [1, "one", [1], ["one"]])
+def test_hide_index_level(mi_styler, level):
+    mi_styler.index.names, mi_styler.columns.names = ["zero", "one"], ["zero", "one"]
+    ctx = mi_styler.hide(axis="index", level=level)._translate(False, True)
+    assert len(ctx["head"][0]) == 3
+    assert len(ctx["head"][1]) == 3
+    assert len(ctx["head"][2]) == 4
+    assert ctx["head"][2][0]["is_visible"]
+    assert not ctx["head"][2][1]["is_visible"]
+
+    assert ctx["body"][0][0]["is_visible"]
+    assert not ctx["body"][0][1]["is_visible"]
+    assert ctx["body"][1][0]["is_visible"]
+    assert not ctx["body"][1][1]["is_visible"]
+
+
+@pytest.mark.parametrize("level", [1, "one", [1], ["one"]])
+@pytest.mark.parametrize("names", [True, False])
+def test_hide_columns_level(mi_styler, level, names):
+    mi_styler.columns.names = ["zero", "one"]
+    if names:
+        mi_styler.index.names = ["zero", "one"]
+    ctx = mi_styler.hide(axis="columns", level=level)._translate(True, False)
+    assert len(ctx["head"]) == (2 if names else 1)
+
+
+@pytest.mark.parametrize("method", ["map", "apply"])
+@pytest.mark.parametrize("axis", ["index", "columns"])
+def test_apply_map_header(method, axis):
+    # GH 41893
+    df = DataFrame({"A": [0, 0], "B": [1, 1]}, index=["C", "D"])
+    func = {
+        "apply": lambda s: ["attr: val" if ("A" in v or "C" in v) else "" for v in s],
+        "map": lambda v: "attr: val" if ("A" in v or "C" in v) else "",
+    }
+
+    # test execution added to todo
+    result = getattr(df.style, f"{method}_index")(func[method], axis=axis)
+    assert len(result._todo) == 1
+    assert len(getattr(result, f"ctx_{axis}")) == 0
+
+    # test ctx object on compute
+    result._compute()
+    expected = {
+        (0, 0): [("attr", "val")],
+    }
+    assert getattr(result, f"ctx_{axis}") == expected
+
+
+@pytest.mark.parametrize("method", ["apply", "map"])
+@pytest.mark.parametrize("axis", ["index", "columns"])
+def test_apply_map_header_mi(mi_styler, method, axis):
+    # GH 41893
+    func = {
+        "apply": lambda s: ["attr: val;" if "b" in v else "" for v in s],
+        "map": lambda v: "attr: val" if "b" in v else "",
+    }
+    result = getattr(mi_styler, f"{method}_index")(func[method], axis=axis)._compute()
+    expected = {(1, 1): [("attr", "val")]}
+    assert getattr(result, f"ctx_{axis}") == expected
+
+
+def test_apply_map_header_raises(mi_styler):
+    # GH 41893
+    with pytest.raises(ValueError, match="No axis named bad for object type DataFrame"):
+        mi_styler.map_index(lambda v: "attr: val;", axis="bad")._compute()
+
+
+class TestStyler:
+    def test_init_non_pandas(self):
+        msg = "``data`` must be a Series or DataFrame"
+        with pytest.raises(TypeError, match=msg):
+            Styler([1, 2, 3])
+
+    def test_init_series(self):
+        result = Styler(Series([1, 2]))
+        assert result.data.ndim == 2
+
+    def test_repr_html_ok(self, styler):
+        styler._repr_html_()
+
+    def test_repr_html_mathjax(self, styler):
+        # gh-19824 / 41395
+        assert "tex2jax_ignore" not in styler._repr_html_()
+
+        with option_context("styler.html.mathjax", False):
+            assert "tex2jax_ignore" in styler._repr_html_()
+
+    def test_update_ctx(self, styler):
+        styler._update_ctx(DataFrame({"A": ["color: red", "color: blue"]}))
+        expected = {(0, 0): [("color", "red")], (1, 0): [("color", "blue")]}
+        assert styler.ctx == expected
+
+    def test_update_ctx_flatten_multi_and_trailing_semi(self, styler):
+        attrs = DataFrame({"A": ["color: red; foo: bar", "color:blue ; foo: baz;"]})
+        styler._update_ctx(attrs)
+        expected = {
+            (0, 0): [("color", "red"), ("foo", "bar")],
+            (1, 0): [("color", "blue"), ("foo", "baz")],
+        }
+        assert styler.ctx == expected
+
+    def test_render(self):
+        df = DataFrame({"A": [0, 1]})
+        style = lambda x: Series(["color: red", "color: blue"], name=x.name)
+        s = Styler(df, uuid="AB").apply(style)
+        s.to_html()
+        # it worked?
+
+    def test_multiple_render(self, df):
+        # GH 39396
+        s = Styler(df, uuid_len=0).map(lambda x: "color: red;", subset=["A"])
+        s.to_html()  # do 2 renders to ensure css styles not duplicated
+        assert (
+            '<style type="text/css">\n#T__row0_col0, #T__row1_col0 {\n'
+            "  color: red;\n}\n</style>" in s.to_html()
+        )
+
+    def test_render_empty_dfs(self):
+        empty_df = DataFrame()
+        es = Styler(empty_df)
+        es.to_html()
+        # An index but no columns
+        DataFrame(columns=["a"]).style.to_html()
+        # A column but no index
+        DataFrame(index=["a"]).style.to_html()
+        # No IndexError raised?
+
+    def test_render_double(self):
+        df = DataFrame({"A": [0, 1]})
+        style = lambda x: Series(
+            ["color: red; border: 1px", "color: blue; border: 2px"], name=x.name
+        )
+        s = Styler(df, uuid="AB").apply(style)
+        s.to_html()
+        # it worked?
+
+    def test_set_properties(self):
+        df = DataFrame({"A": [0, 1]})
+        result = df.style.set_properties(color="white", size="10px")._compute().ctx
+        # order is deterministic
+        v = [("color", "white"), ("size", "10px")]
+        expected = {(0, 0): v, (1, 0): v}
+        assert result.keys() == expected.keys()
+        for v1, v2 in zip(result.values(), expected.values()):
+            assert sorted(v1) == sorted(v2)
+
+    def test_set_properties_subset(self):
+        df = DataFrame({"A": [0, 1]})
+        result = (
+            df.style.set_properties(subset=IndexSlice[0, "A"], color="white")
+            ._compute()
+            .ctx
+        )
+        expected = {(0, 0): [("color", "white")]}
+        assert result == expected
+
+    def test_empty_index_name_doesnt_display(self, blank_value):
+        # https://github.com/pandas-dev/pandas/pull/12090#issuecomment-180695902
+        df = DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
+        result = df.style._translate(True, True)
+        assert len(result["head"]) == 1
+        expected = {
+            "class": "blank level0",
+            "type": "th",
+            "value": blank_value,
+            "is_visible": True,
+            "display_value": blank_value,
+        }
+        assert expected.items() <= result["head"][0][0].items()
+
+    def test_index_name(self):
+        # https://github.com/pandas-dev/pandas/issues/11655
+        df = DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
+        result = df.set_index("A").style._translate(True, True)
+        expected = {
+            "class": "index_name level0",
+            "type": "th",
+            "value": "A",
+            "is_visible": True,
+            "display_value": "A",
+        }
+        assert expected.items() <= result["head"][1][0].items()
+
+    def test_numeric_columns(self):
+        # https://github.com/pandas-dev/pandas/issues/12125
+        # smoke test for _translate
+        df = DataFrame({0: [1, 2, 3]})
+        df.style._translate(True, True)
+
+    def test_apply_axis(self):
+        df = DataFrame({"A": [0, 0], "B": [1, 1]})
+        f = lambda x: [f"val: {x.max()}" for v in x]
+        result = df.style.apply(f, axis=1)
+        assert len(result._todo) == 1
+        assert len(result.ctx) == 0
+        result._compute()
+        expected = {
+            (0, 0): [("val", "1")],
+            (0, 1): [("val", "1")],
+            (1, 0): [("val", "1")],
+            (1, 1): [("val", "1")],
+        }
+        assert result.ctx == expected
+
+        result = df.style.apply(f, axis=0)
+        expected = {
+            (0, 0): [("val", "0")],
+            (0, 1): [("val", "1")],
+            (1, 0): [("val", "0")],
+            (1, 1): [("val", "1")],
+        }
+        result._compute()
+        assert result.ctx == expected
+        result = df.style.apply(f)  # default
+        result._compute()
+        assert result.ctx == expected
+
+    @pytest.mark.parametrize("axis", [0, 1])
+    def test_apply_series_return(self, axis):
+        # GH 42014
+        df = DataFrame([[1, 2], [3, 4]], index=["X", "Y"], columns=["X", "Y"])
+
+        # test Series return where len(Series) < df.index or df.columns but labels OK
+        func = lambda s: Series(["color: red;"], index=["Y"])
+        result = df.style.apply(func, axis=axis)._compute().ctx
+        assert result[(1, 1)] == [("color", "red")]
+        assert result[(1 - axis, axis)] == [("color", "red")]
+
+        # test Series return where labels align but different order
+        func = lambda s: Series(["color: red;", "color: blue;"], index=["Y", "X"])
+        result = df.style.apply(func, axis=axis)._compute().ctx
+        assert result[(0, 0)] == [("color", "blue")]
+        assert result[(1, 1)] == [("color", "red")]
+        assert result[(1 - axis, axis)] == [("color", "red")]
+        assert result[(axis, 1 - axis)] == [("color", "blue")]
+
+    @pytest.mark.parametrize("index", [False, True])
+    @pytest.mark.parametrize("columns", [False, True])
+    def test_apply_dataframe_return(self, index, columns):
+        # GH 42014
+        df = DataFrame([[1, 2], [3, 4]], index=["X", "Y"], columns=["X", "Y"])
+        idxs = ["X", "Y"] if index else ["Y"]
+        cols = ["X", "Y"] if columns else ["Y"]
+        df_styles = DataFrame("color: red;", index=idxs, columns=cols)
+        result = df.style.apply(lambda x: df_styles, axis=None)._compute().ctx
+
+        assert result[(1, 1)] == [("color", "red")]  # (Y,Y) styles always present
+        assert (result[(0, 1)] == [("color", "red")]) is index  # (X,Y) only if index
+        assert (result[(1, 0)] == [("color", "red")]) is columns  # (Y,X) only if cols
+        assert (result[(0, 0)] == [("color", "red")]) is (index and columns)  # (X,X)
+
+    @pytest.mark.parametrize(
+        "slice_",
+        [
+            IndexSlice[:],
+            IndexSlice[:, ["A"]],
+            IndexSlice[[1], :],
+            IndexSlice[[1], ["A"]],
+            IndexSlice[:2, ["A", "B"]],
+        ],
+    )
+    @pytest.mark.parametrize("axis", [0, 1])
+    def test_apply_subset(self, slice_, axis, df):
+        def h(x, color="bar"):
+            return Series(f"color: {color}", index=x.index, name=x.name)
+
+        result = df.style.apply(h, axis=axis, subset=slice_, color="baz")._compute().ctx
+        expected = {
+            (r, c): [("color", "baz")]
+            for r, row in enumerate(df.index)
+            for c, col in enumerate(df.columns)
+            if row in df.loc[slice_].index and col in df.loc[slice_].columns
+        }
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "slice_",
+        [
+            IndexSlice[:],
+            IndexSlice[:, ["A"]],
+            IndexSlice[[1], :],
+            IndexSlice[[1], ["A"]],
+            IndexSlice[:2, ["A", "B"]],
+        ],
+    )
+    def test_map_subset(self, slice_, df):
+        result = df.style.map(lambda x: "color:baz;", subset=slice_)._compute().ctx
+        expected = {
+            (r, c): [("color", "baz")]
+            for r, row in enumerate(df.index)
+            for c, col in enumerate(df.columns)
+            if row in df.loc[slice_].index and col in df.loc[slice_].columns
+        }
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "slice_",
+        [
+            IndexSlice[:, IndexSlice["x", "A"]],
+            IndexSlice[:, IndexSlice[:, "A"]],
+            IndexSlice[:, IndexSlice[:, ["A", "C"]]],  # missing col element
+            IndexSlice[IndexSlice["a", 1], :],
+            IndexSlice[IndexSlice[:, 1], :],
+            IndexSlice[IndexSlice[:, [1, 3]], :],  # missing row element
+            IndexSlice[:, ("x", "A")],
+            IndexSlice[("a", 1), :],
+        ],
+    )
+    def test_map_subset_multiindex(self, slice_):
+        # GH 19861
+        # edited for GH 33562
+        if (
+            isinstance(slice_[-1], tuple)
+            and isinstance(slice_[-1][-1], list)
+            and "C" in slice_[-1][-1]
+        ):
+            ctx = pytest.raises(KeyError, match="C")
+        elif (
+            isinstance(slice_[0], tuple)
+            and isinstance(slice_[0][1], list)
+            and 3 in slice_[0][1]
+        ):
+            ctx = pytest.raises(KeyError, match="3")
+        else:
+            ctx = contextlib.nullcontext()
+
+        idx = MultiIndex.from_product([["a", "b"], [1, 2]])
+        col = MultiIndex.from_product([["x", "y"], ["A", "B"]])
+        df = DataFrame(np.random.default_rng(2).random((4, 4)), columns=col, index=idx)
+
+        with ctx:
+            df.style.map(lambda x: "color: red;", subset=slice_).to_html()
+
+    def test_map_subset_multiindex_code(self):
+        # https://github.com/pandas-dev/pandas/issues/25858
+        # Checks styler.map works with multindex when codes are provided
+        codes = np.array([[0, 0, 1, 1], [0, 1, 0, 1]])
+        columns = MultiIndex(
+            levels=[["a", "b"], ["%", "#"]], codes=codes, names=["", ""]
+        )
+        df = DataFrame(
+            [[1, -1, 1, 1], [-1, 1, 1, 1]], index=["hello", "world"], columns=columns
+        )
+        pct_subset = IndexSlice[:, IndexSlice[:, "%":"%"]]
+
+        def color_negative_red(val):
+            color = "red" if val < 0 else "black"
+            return f"color: {color}"
+
+        df.loc[pct_subset]
+        df.style.map(color_negative_red, subset=pct_subset)
+
+    @pytest.mark.parametrize(
+        "stylefunc", ["background_gradient", "bar", "text_gradient"]
+    )
+    def test_subset_for_boolean_cols(self, stylefunc):
+        # GH47838
+        df = DataFrame(
+            [
+                [1, 2],
+                [3, 4],
+            ],
+            columns=[False, True],
+        )
+        styled = getattr(df.style, stylefunc)()
+        styled._compute()
+        assert set(styled.ctx) == {(0, 0), (0, 1), (1, 0), (1, 1)}
+
+    def test_empty(self):
+        df = DataFrame({"A": [1, 0]})
+        s = df.style
+        s.ctx = {(0, 0): [("color", "red")], (1, 0): [("", "")]}
+
+        result = s._translate(True, True)["cellstyle"]
+        expected = [
+            {"props": [("color", "red")], "selectors": ["row0_col0"]},
+            {"props": [("", "")], "selectors": ["row1_col0"]},
+        ]
+        assert result == expected
+
+    def test_duplicate(self):
+        df = DataFrame({"A": [1, 0]})
+        s = df.style
+        s.ctx = {(0, 0): [("color", "red")], (1, 0): [("color", "red")]}
+
+        result = s._translate(True, True)["cellstyle"]
+        expected = [
+            {"props": [("color", "red")], "selectors": ["row0_col0", "row1_col0"]}
+        ]
+        assert result == expected
+
+    def test_init_with_na_rep(self):
+        # GH 21527 28358
+        df = DataFrame([[None, None], [1.1, 1.2]], columns=["A", "B"])
+
+        ctx = Styler(df, na_rep="NA")._translate(True, True)
+        assert ctx["body"][0][1]["display_value"] == "NA"
+        assert ctx["body"][0][2]["display_value"] == "NA"
+
+    def test_caption(self, df):
+        styler = Styler(df, caption="foo")
+        result = styler.to_html()
+        assert all(["caption" in result, "foo" in result])
+
+        styler = df.style
+        result = styler.set_caption("baz")
+        assert styler is result
+        assert styler.caption == "baz"
+
+    def test_uuid(self, df):
+        styler = Styler(df, uuid="abc123")
+        result = styler.to_html()
+        assert "abc123" in result
+
+        styler = df.style
+        result = styler.set_uuid("aaa")
+        assert result is styler
+        assert result.uuid == "aaa"
+
+    def test_unique_id(self):
+        # See https://github.com/pandas-dev/pandas/issues/16780
+        df = DataFrame({"a": [1, 3, 5, 6], "b": [2, 4, 12, 21]})
+        result = df.style.to_html(uuid="test")
+        assert "test" in result
+        ids = re.findall('id="(.*?)"', result)
+        assert np.unique(ids).size == len(ids)
+
+    def test_table_styles(self, df):
+        style = [{"selector": "th", "props": [("foo", "bar")]}]  # default format
+        styler = Styler(df, table_styles=style)
+        result = " ".join(styler.to_html().split())
+        assert "th { foo: bar; }" in result
+
+        styler = df.style
+        result = styler.set_table_styles(style)
+        assert styler is result
+        assert styler.table_styles == style
+
+        # GH 39563
+        style = [{"selector": "th", "props": "foo:bar;"}]  # css string format
+        styler = df.style.set_table_styles(style)
+        result = " ".join(styler.to_html().split())
+        assert "th { foo: bar; }" in result
+
+    def test_table_styles_multiple(self, df):
+        ctx = df.style.set_table_styles(
+            [
+                {"selector": "th,td", "props": "color:red;"},
+                {"selector": "tr", "props": "color:green;"},
+            ]
+        )._translate(True, True)["table_styles"]
+        assert ctx == [
+            {"selector": "th", "props": [("color", "red")]},
+            {"selector": "td", "props": [("color", "red")]},
+            {"selector": "tr", "props": [("color", "green")]},
+        ]
+
+    def test_table_styles_dict_multiple_selectors(self, df):
+        # GH 44011
+        result = df.style.set_table_styles(
+            {
+                "B": [
+                    {"selector": "th,td", "props": [("border-left", "2px solid black")]}
+                ]
+            }
+        )._translate(True, True)["table_styles"]
+
+        expected = [
+            {"selector": "th.col1", "props": [("border-left", "2px solid black")]},
+            {"selector": "td.col1", "props": [("border-left", "2px solid black")]},
+        ]
+
+        assert result == expected
+
+    def test_maybe_convert_css_to_tuples(self):
+        expected = [("a", "b"), ("c", "d e")]
+        assert maybe_convert_css_to_tuples("a:b;c:d e;") == expected
+        assert maybe_convert_css_to_tuples("a: b ;c:  d e  ") == expected
+        expected = []
+        assert maybe_convert_css_to_tuples("") == expected
+
+    def test_maybe_convert_css_to_tuples_err(self):
+        msg = "Styles supplied as string must follow CSS rule formats"
+        with pytest.raises(ValueError, match=msg):
+            maybe_convert_css_to_tuples("err")
+
+    def test_table_attributes(self, df):
+        attributes = 'class="foo" data-bar'
+        styler = Styler(df, table_attributes=attributes)
+        result = styler.to_html()
+        assert 'class="foo" data-bar' in result
+
+        result = df.style.set_table_attributes(attributes).to_html()
+        assert 'class="foo" data-bar' in result
+
+    def test_apply_none(self):
+        def f(x):
+            return DataFrame(
+                np.where(x == x.max(), "color: red", ""),
+                index=x.index,
+                columns=x.columns,
+            )
+
+        result = DataFrame([[1, 2], [3, 4]]).style.apply(f, axis=None)._compute().ctx
+        assert result[(1, 1)] == [("color", "red")]
+
+    def test_trim(self, df):
+        result = df.style.to_html()  # trim=True
+        assert result.count("#") == 0
+
+        result = df.style.highlight_max().to_html()
+        assert result.count("#") == len(df.columns)
+
+    def test_export(self, df, styler):
+        f = lambda x: "color: red" if x > 0 else "color: blue"
+        g = lambda x, z: f"color: {z}" if x > 0 else f"color: {z}"
+        style1 = styler
+        style1.map(f).map(g, z="b").highlight_max()._compute()  # = render
+        result = style1.export()
+        style2 = df.style
+        style2.use(result)
+        assert style1._todo == style2._todo
+        style2.to_html()
+
+    def test_bad_apply_shape(self):
+        df = DataFrame([[1, 2], [3, 4]], index=["A", "B"], columns=["X", "Y"])
+
+        msg = "resulted in the apply method collapsing to a Series."
+        with pytest.raises(ValueError, match=msg):
+            df.style._apply(lambda x: "x")
+
+        msg = "created invalid {} labels"
+        with pytest.raises(ValueError, match=msg.format("index")):
+            df.style._apply(lambda x: [""])
+
+        with pytest.raises(ValueError, match=msg.format("index")):
+            df.style._apply(lambda x: ["", "", "", ""])
+
+        with pytest.raises(ValueError, match=msg.format("index")):
+            df.style._apply(lambda x: Series(["a:v;", ""], index=["A", "C"]), axis=0)
+
+        with pytest.raises(ValueError, match=msg.format("columns")):
+            df.style._apply(lambda x: ["", "", ""], axis=1)
+
+        with pytest.raises(ValueError, match=msg.format("columns")):
+            df.style._apply(lambda x: Series(["a:v;", ""], index=["X", "Z"]), axis=1)
+
+        msg = "returned ndarray with wrong shape"
+        with pytest.raises(ValueError, match=msg):
+            df.style._apply(lambda x: np.array([[""], [""]]), axis=None)
+
+    def test_apply_bad_return(self):
+        def f(x):
+            return ""
+
+        df = DataFrame([[1, 2], [3, 4]])
+        msg = (
+            "must return a DataFrame or ndarray when passed to `Styler.apply` "
+            "with axis=None"
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.style._apply(f, axis=None)
+
+    @pytest.mark.parametrize("axis", ["index", "columns"])
+    def test_apply_bad_labels(self, axis):
+        def f(x):
+            return DataFrame(**{axis: ["bad", "labels"]})
+
+        df = DataFrame([[1, 2], [3, 4]])
+        msg = f"created invalid {axis} labels."
+        with pytest.raises(ValueError, match=msg):
+            df.style._apply(f, axis=None)
+
+    def test_get_level_lengths(self):
+        index = MultiIndex.from_product([["a", "b"], [0, 1, 2]])
+        expected = {
+            (0, 0): 3,
+            (0, 3): 3,
+            (1, 0): 1,
+            (1, 1): 1,
+            (1, 2): 1,
+            (1, 3): 1,
+            (1, 4): 1,
+            (1, 5): 1,
+        }
+        result = _get_level_lengths(index, sparsify=True, max_index=100)
+        tm.assert_dict_equal(result, expected)
+
+        expected = {
+            (0, 0): 1,
+            (0, 1): 1,
+            (0, 2): 1,
+            (0, 3): 1,
+            (0, 4): 1,
+            (0, 5): 1,
+            (1, 0): 1,
+            (1, 1): 1,
+            (1, 2): 1,
+            (1, 3): 1,
+            (1, 4): 1,
+            (1, 5): 1,
+        }
+        result = _get_level_lengths(index, sparsify=False, max_index=100)
+        tm.assert_dict_equal(result, expected)
+
+    def test_get_level_lengths_un_sorted(self):
+        index = MultiIndex.from_arrays([[1, 1, 2, 1], ["a", "b", "b", "d"]])
+        expected = {
+            (0, 0): 2,
+            (0, 2): 1,
+            (0, 3): 1,
+            (1, 0): 1,
+            (1, 1): 1,
+            (1, 2): 1,
+            (1, 3): 1,
+        }
+        result = _get_level_lengths(index, sparsify=True, max_index=100)
+        tm.assert_dict_equal(result, expected)
+
+        expected = {
+            (0, 0): 1,
+            (0, 1): 1,
+            (0, 2): 1,
+            (0, 3): 1,
+            (1, 0): 1,
+            (1, 1): 1,
+            (1, 2): 1,
+            (1, 3): 1,
+        }
+        result = _get_level_lengths(index, sparsify=False, max_index=100)
+        tm.assert_dict_equal(result, expected)
+
+    def test_mi_sparse_index_names(self, blank_value):
+        # Test the class names and displayed value are correct on rendering MI names
+        df = DataFrame(
+            {"A": [1, 2]},
+            index=MultiIndex.from_arrays(
+                [["a", "a"], [0, 1]], names=["idx_level_0", "idx_level_1"]
+            ),
+        )
+        result = df.style._translate(True, True)
+        head = result["head"][1]
+        expected = [
+            {
+                "class": "index_name level0",
+                "display_value": "idx_level_0",
+                "is_visible": True,
+            },
+            {
+                "class": "index_name level1",
+                "display_value": "idx_level_1",
+                "is_visible": True,
+            },
+            {
+                "class": "blank col0",
+                "display_value": blank_value,
+                "is_visible": True,
+            },
+        ]
+        for i, expected_dict in enumerate(expected):
+            assert expected_dict.items() <= head[i].items()
+
+    def test_mi_sparse_column_names(self, blank_value):
+        df = DataFrame(
+            np.arange(16).reshape(4, 4),
+            index=MultiIndex.from_arrays(
+                [["a", "a", "b", "a"], [0, 1, 1, 2]],
+                names=["idx_level_0", "idx_level_1"],
+            ),
+            columns=MultiIndex.from_arrays(
+                [["C1", "C1", "C2", "C2"], [1, 0, 1, 0]], names=["colnam_0", "colnam_1"]
+            ),
+        )
+        result = Styler(df, cell_ids=False)._translate(True, True)
+
+        for level in [0, 1]:
+            head = result["head"][level]
+            expected = [
+                {
+                    "class": "blank",
+                    "display_value": blank_value,
+                    "is_visible": True,
+                },
+                {
+                    "class": f"index_name level{level}",
+                    "display_value": f"colnam_{level}",
+                    "is_visible": True,
+                },
+            ]
+            for i, expected_dict in enumerate(expected):
+                assert expected_dict.items() <= head[i].items()
+
+    def test_hide_column_headers(self, df, styler):
+        ctx = styler.hide(axis="columns")._translate(True, True)
+        assert len(ctx["head"]) == 0  # no header entries with an unnamed index
+
+        df.index.name = "some_name"
+        ctx = df.style.hide(axis="columns")._translate(True, True)
+        assert len(ctx["head"]) == 1
+        # index names still visible, changed in #42101, reverted in 43404
+
+    def test_hide_single_index(self, df):
+        # GH 14194
+        # single unnamed index
+        ctx = df.style._translate(True, True)
+        assert ctx["body"][0][0]["is_visible"]
+        assert ctx["head"][0][0]["is_visible"]
+        ctx2 = df.style.hide(axis="index")._translate(True, True)
+        assert not ctx2["body"][0][0]["is_visible"]
+        assert not ctx2["head"][0][0]["is_visible"]
+
+        # single named index
+        ctx3 = df.set_index("A").style._translate(True, True)
+        assert ctx3["body"][0][0]["is_visible"]
+        assert len(ctx3["head"]) == 2  # 2 header levels
+        assert ctx3["head"][0][0]["is_visible"]
+
+        ctx4 = df.set_index("A").style.hide(axis="index")._translate(True, True)
+        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):
+        # GH 14194
+        df = DataFrame(
+            {"A": [1, 2], "B": [1, 2]},
+            index=MultiIndex.from_arrays(
+                [["a", "a"], [0, 1]], names=["idx_level_0", "idx_level_1"]
+            ),
+        )
+        ctx1 = df.style._translate(True, True)
+        # tests for 'a' and '0'
+        assert ctx1["body"][0][0]["is_visible"]
+        assert ctx1["body"][0][1]["is_visible"]
+        # check for blank header rows
+        assert len(ctx1["head"][0]) == 4  # two visible indexes and two data columns
+
+        ctx2 = df.style.hide(axis="index")._translate(True, True)
+        # tests for 'a' and '0'
+        assert not ctx2["body"][0][0]["is_visible"]
+        assert not ctx2["body"][0][1]["is_visible"]
+        # check for blank header rows
+        assert len(ctx2["head"][0]) == 3  # one hidden (col name) and two data columns
+        assert not ctx2["head"][0][0]["is_visible"]
+
+    def test_hide_columns_single_level(self, df):
+        # GH 14194
+        # test hiding single column
+        ctx = df.style._translate(True, True)
+        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 = df.style.hide("A", axis="columns")._translate(True, True)
+        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 multiple columns
+        ctx = df.style.hide(["A", "B"], axis="columns")._translate(True, True)
+        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_index_mult_levels(self):
+        # GH 14194
+        # setup dataframe with multiple column levels and indices
+        i1 = MultiIndex.from_arrays(
+            [["a", "a"], [0, 1]], names=["idx_level_0", "idx_level_1"]
+        )
+        i2 = MultiIndex.from_arrays(
+            [["b", "b"], [0, 1]], names=["col_level_0", "col_level_1"]
+        )
+        df = DataFrame([[1, 2], [3, 4]], index=i1, columns=i2)
+        ctx = df.style._translate(True, True)
+        # column headers
+        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"]
+        # 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"
+
+        # hide top column level, which hides both columns
+        ctx = df.style.hide("b", axis="columns")._translate(True, True)
+        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([("b", 0)], axis="columns")._translate(True, True)
+        assert not ctx["head"][0][2]["is_visible"]  # b
+        assert ctx["head"][0][3]["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([("b", 1)], axis=1).hide(axis=0)._translate(True, True)
+        assert not ctx["body"][0][0]["is_visible"]  # index
+        assert len(ctx["head"][0]) == 3
+        assert ctx["head"][0][1]["is_visible"]  # b
+        assert ctx["head"][1][1]["is_visible"]  # 0
+        assert not ctx["head"][1][2]["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"
+
+        # hide top row level, which hides both rows so body empty
+        ctx = df.style.hide("a", axis="index")._translate(True, True)
+        assert ctx["body"] == []
+
+        # hide first row only
+        ctx = df.style.hide(("a", 0), axis="index")._translate(True, True)
+        for i in [0, 1, 2, 3]:
+            assert "row1" in ctx["body"][0][i]["class"]  # row0 not included in body
+            assert ctx["body"][0][i]["is_visible"]
+
+    def test_pipe(self, df):
+        def set_caption_from_template(styler, a, b):
+            return styler.set_caption(f"Dataframe with a = {a} and b = {b}")
+
+        styler = df.style.pipe(set_caption_from_template, "A", b="B")
+        assert "Dataframe with a = A and b = B" in styler.to_html()
+
+        # Test with an argument that is a (callable, keyword_name) pair.
+        def f(a, b, styler):
+            return (a, b, styler)
+
+        styler = df.style
+        result = styler.pipe((f, "styler"), a=1, b=2)
+        assert result == (1, 2, styler)
+
+    def test_no_cell_ids(self):
+        # GH 35588
+        # GH 35663
+        df = DataFrame(data=[[0]])
+        styler = Styler(df, uuid="_", cell_ids=False)
+        styler.to_html()
+        s = styler.to_html()  # render twice to ensure ctx is not updated
+        assert s.find('<td class="data row0 col0" >') != -1
+
+    @pytest.mark.parametrize(
+        "classes",
+        [
+            DataFrame(
+                data=[["", "test-class"], [np.nan, None]],
+                columns=["A", "B"],
+                index=["a", "b"],
+            ),
+            DataFrame(data=[["test-class"]], columns=["B"], index=["a"]),
+            DataFrame(data=[["test-class", "unused"]], columns=["B", "C"], index=["a"]),
+        ],
+    )
+    def test_set_data_classes(self, classes):
+        # GH 36159
+        df = DataFrame(data=[[0, 1], [2, 3]], columns=["A", "B"], index=["a", "b"])
+        s = Styler(df, uuid_len=0, cell_ids=False).set_td_classes(classes).to_html()
+        assert '<td class="data row0 col0" >0</td>' in s
+        assert '<td class="data row0 col1 test-class" >1</td>' in s
+        assert '<td class="data row1 col0" >2</td>' in s
+        assert '<td class="data row1 col1" >3</td>' in s
+        # GH 39317
+        s = Styler(df, uuid_len=0, cell_ids=True).set_td_classes(classes).to_html()
+        assert '<td id="T__row0_col0" class="data row0 col0" >0</td>' in s
+        assert '<td id="T__row0_col1" class="data row0 col1 test-class" >1</td>' in s
+        assert '<td id="T__row1_col0" class="data row1 col0" >2</td>' in s
+        assert '<td id="T__row1_col1" class="data row1 col1" >3</td>' in s
+
+    def test_set_data_classes_reindex(self):
+        # GH 39317
+        df = DataFrame(
+            data=[[0, 1, 2], [3, 4, 5], [6, 7, 8]], columns=[0, 1, 2], index=[0, 1, 2]
+        )
+        classes = DataFrame(
+            data=[["mi", "ma"], ["mu", "mo"]],
+            columns=[0, 2],
+            index=[0, 2],
+        )
+        s = Styler(df, uuid_len=0).set_td_classes(classes).to_html()
+        assert '<td id="T__row0_col0" class="data row0 col0 mi" >0</td>' in s
+        assert '<td id="T__row0_col2" class="data row0 col2 ma" >2</td>' in s
+        assert '<td id="T__row1_col1" class="data row1 col1" >4</td>' in s
+        assert '<td id="T__row2_col0" class="data row2 col0 mu" >6</td>' in s
+        assert '<td id="T__row2_col2" class="data row2 col2 mo" >8</td>' in s
+
+    def test_chaining_table_styles(self):
+        # GH 35607
+        df = DataFrame(data=[[0, 1], [1, 2]], columns=["A", "B"])
+        styler = df.style.set_table_styles(
+            [{"selector": "", "props": [("background-color", "yellow")]}]
+        ).set_table_styles(
+            [{"selector": ".col0", "props": [("background-color", "blue")]}],
+            overwrite=False,
+        )
+        assert len(styler.table_styles) == 2
+
+    def test_column_and_row_styling(self):
+        # GH 35607
+        df = DataFrame(data=[[0, 1], [1, 2]], columns=["A", "B"])
+        s = Styler(df, uuid_len=0)
+        s = s.set_table_styles({"A": [{"selector": "", "props": [("color", "blue")]}]})
+        assert "#T_ .col0 {\n  color: blue;\n}" in s.to_html()
+        s = s.set_table_styles(
+            {0: [{"selector": "", "props": [("color", "blue")]}]}, axis=1
+        )
+        assert "#T_ .row0 {\n  color: blue;\n}" in s.to_html()
+
+    @pytest.mark.parametrize("len_", [1, 5, 32, 33, 100])
+    def test_uuid_len(self, len_):
+        # GH 36345
+        df = DataFrame(data=[["A"]])
+        s = Styler(df, uuid_len=len_, cell_ids=False).to_html()
+        strt = s.find('id="T_')
+        end = s[strt + 6 :].find('"')
+        if len_ > 32:
+            assert end == 32
+        else:
+            assert end == len_
+
+    @pytest.mark.parametrize("len_", [-2, "bad", None])
+    def test_uuid_len_raises(self, len_):
+        # GH 36345
+        df = DataFrame(data=[["A"]])
+        msg = "``uuid_len`` must be an integer in range \\[0, 32\\]."
+        with pytest.raises(TypeError, match=msg):
+            Styler(df, uuid_len=len_, cell_ids=False).to_html()
+
+    @pytest.mark.parametrize(
+        "slc",
+        [
+            IndexSlice[:, :],
+            IndexSlice[:, 1],
+            IndexSlice[1, :],
+            IndexSlice[[1], [1]],
+            IndexSlice[1, [1]],
+            IndexSlice[[1], 1],
+            IndexSlice[1],
+            IndexSlice[1, 1],
+            slice(None, None, None),
+            [0, 1],
+            np.array([0, 1]),
+            Series([0, 1]),
+        ],
+    )
+    def test_non_reducing_slice(self, slc):
+        df = DataFrame([[0, 1], [2, 3]])
+
+        tslice_ = non_reducing_slice(slc)
+        assert isinstance(df.loc[tslice_], DataFrame)
+
+    @pytest.mark.parametrize("box", [list, Series, np.array])
+    def test_list_slice(self, box):
+        # like dataframe getitem
+        subset = box(["A"])
+
+        df = DataFrame({"A": [1, 2], "B": [3, 4]}, index=["A", "B"])
+        expected = IndexSlice[:, ["A"]]
+
+        result = non_reducing_slice(subset)
+        tm.assert_frame_equal(df.loc[result], df.loc[expected])
+
+    def test_non_reducing_slice_on_multiindex(self):
+        # GH 19861
+        dic = {
+            ("a", "d"): [1, 4],
+            ("a", "c"): [2, 3],
+            ("b", "c"): [3, 2],
+            ("b", "d"): [4, 1],
+        }
+        df = DataFrame(dic, index=[0, 1])
+        idx = IndexSlice
+        slice_ = idx[:, idx["b", "d"]]
+        tslice_ = non_reducing_slice(slice_)
+
+        result = df.loc[tslice_]
+        expected = DataFrame({("b", "d"): [4, 1]})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "slice_",
+        [
+            IndexSlice[:, :],
+            # check cols
+            IndexSlice[:, IndexSlice[["a"]]],  # inferred deeper need list
+            IndexSlice[:, IndexSlice[["a"], ["c"]]],  # inferred deeper need list
+            IndexSlice[:, IndexSlice["a", "c", :]],
+            IndexSlice[:, IndexSlice["a", :, "e"]],
+            IndexSlice[:, IndexSlice[:, "c", "e"]],
+            IndexSlice[:, IndexSlice["a", ["c", "d"], :]],  # check list
+            IndexSlice[:, IndexSlice["a", ["c", "d", "-"], :]],  # don't allow missing
+            IndexSlice[:, IndexSlice["a", ["c", "d", "-"], "e"]],  # no slice
+            # check rows
+            IndexSlice[IndexSlice[["U"]], :],  # inferred deeper need list
+            IndexSlice[IndexSlice[["U"], ["W"]], :],  # inferred deeper need list
+            IndexSlice[IndexSlice["U", "W", :], :],
+            IndexSlice[IndexSlice["U", :, "Y"], :],
+            IndexSlice[IndexSlice[:, "W", "Y"], :],
+            IndexSlice[IndexSlice[:, "W", ["Y", "Z"]], :],  # check list
+            IndexSlice[IndexSlice[:, "W", ["Y", "Z", "-"]], :],  # don't allow missing
+            IndexSlice[IndexSlice["U", "W", ["Y", "Z", "-"]], :],  # no slice
+            # check simultaneous
+            IndexSlice[IndexSlice[:, "W", "Y"], IndexSlice["a", "c", :]],
+        ],
+    )
+    def test_non_reducing_multi_slice_on_multiindex(self, slice_):
+        # GH 33562
+        cols = MultiIndex.from_product([["a", "b"], ["c", "d"], ["e", "f"]])
+        idxs = MultiIndex.from_product([["U", "V"], ["W", "X"], ["Y", "Z"]])
+        df = DataFrame(np.arange(64).reshape(8, 8), columns=cols, index=idxs)
+
+        for lvl in [0, 1]:
+            key = slice_[lvl]
+            if isinstance(key, tuple):
+                for subkey in key:
+                    if isinstance(subkey, list) and "-" in subkey:
+                        # not present in the index level, raises KeyError since 2.0
+                        with pytest.raises(KeyError, match="-"):
+                            df.loc[slice_]
+                        return
+
+        expected = df.loc[slice_]
+        result = df.loc[non_reducing_slice(slice_)]
+        tm.assert_frame_equal(result, expected)
+
+
+def test_hidden_index_names(mi_df):
+    mi_df.index.names = ["Lev0", "Lev1"]
+    mi_styler = mi_df.style
+    ctx = mi_styler._translate(True, True)
+    assert len(ctx["head"]) == 3  # 2 column index levels + 1 index names row
+
+    mi_styler.hide(axis="index", names=True)
+    ctx = mi_styler._translate(True, True)
+    assert len(ctx["head"]) == 2  # index names row is unparsed
+    for i in range(4):
+        assert ctx["body"][0][i]["is_visible"]  # 2 index levels + 2 data values visible
+
+    mi_styler.hide(axis="index", level=1)
+    ctx = mi_styler._translate(True, True)
+    assert len(ctx["head"]) == 2  # index names row is still hidden
+    assert ctx["body"][0][0]["is_visible"] is True
+    assert ctx["body"][0][1]["is_visible"] is False
+
+
+def test_hidden_column_names(mi_df):
+    mi_df.columns.names = ["Lev0", "Lev1"]
+    mi_styler = mi_df.style
+    ctx = mi_styler._translate(True, True)
+    assert ctx["head"][0][1]["display_value"] == "Lev0"
+    assert ctx["head"][1][1]["display_value"] == "Lev1"
+
+    mi_styler.hide(names=True, axis="columns")
+    ctx = mi_styler._translate(True, True)
+    assert ctx["head"][0][1]["display_value"] == "&nbsp;"
+    assert ctx["head"][1][1]["display_value"] == "&nbsp;"
+
+    mi_styler.hide(level=0, axis="columns")
+    ctx = mi_styler._translate(True, True)
+    assert len(ctx["head"]) == 1  # no index names and only one visible column headers
+    assert ctx["head"][0][1]["display_value"] == "&nbsp;"
+
+
+@pytest.mark.parametrize("caption", [1, ("a", "b", "c"), (1, "s")])
+def test_caption_raises(mi_styler, caption):
+    msg = "`caption` must be either a string or 2-tuple of strings."
+    with pytest.raises(ValueError, match=msg):
+        mi_styler.set_caption(caption)
+
+
+def test_hiding_headers_over_index_no_sparsify():
+    # GH 43464
+    midx = MultiIndex.from_product([[1, 2], ["a", "a", "b"]])
+    df = DataFrame(9, index=midx, columns=[0])
+    ctx = df.style._translate(False, False)
+    assert len(ctx["body"]) == 6
+    ctx = df.style.hide((1, "a"), axis=0)._translate(False, False)
+    assert len(ctx["body"]) == 4
+    assert "row2" in ctx["body"][0][0]["class"]
+
+
+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((1, "a"), axis="columns")._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():
+    # GH 43464
+    index = MultiIndex.from_arrays([[1, 1, 1, 2, 2, 2], ["a", "a", "b", "a", "a", "b"]])
+    expected = {
+        (0, 2): 1,
+        (0, 3): 1,
+        (0, 4): 1,
+        (0, 5): 1,
+        (1, 2): 1,
+        (1, 3): 1,
+        (1, 4): 1,
+        (1, 5): 1,
+    }
+    result = _get_level_lengths(
+        index,
+        sparsify=False,
+        max_index=100,
+        hidden_elements=[0, 1, 0, 1],  # hidden element can repeat if duplicated index
+    )
+    tm.assert_dict_equal(result, expected)
+
+
+def test_row_trimming_hide_index():
+    # gh 43703
+    df = DataFrame([[1], [2], [3], [4], [5]])
+    with option_context("styler.render.max_rows", 2):
+        ctx = df.style.hide([0, 1], axis="index")._translate(True, True)
+    assert len(ctx["body"]) == 3
+    for r, val in enumerate(["3", "4", "..."]):
+        assert ctx["body"][r][1]["display_value"] == val
+
+
+def test_row_trimming_hide_index_mi():
+    # gh 44247
+    df = DataFrame([[1], [2], [3], [4], [5]])
+    df.index = MultiIndex.from_product([[0], [0, 1, 2, 3, 4]])
+    with option_context("styler.render.max_rows", 2):
+        ctx = df.style.hide([(0, 0), (0, 1)], axis="index")._translate(True, True)
+    assert len(ctx["body"]) == 3
+
+    # level 0 index headers (sparsified)
+    assert {"value": 0, "attributes": 'rowspan="2"', "is_visible": True}.items() <= ctx[
+        "body"
+    ][0][0].items()
+    assert {"value": 0, "attributes": "", "is_visible": False}.items() <= ctx["body"][
+        1
+    ][0].items()
+    assert {"value": "...", "is_visible": True}.items() <= ctx["body"][2][0].items()
+
+    for r, val in enumerate(["2", "3", "..."]):
+        assert ctx["body"][r][1]["display_value"] == val  # level 1 index headers
+    for r, val in enumerate(["3", "4", "..."]):
+        assert ctx["body"][r][2]["display_value"] == val  # data values
+
+
+def test_col_trimming_hide_columns():
+    # gh 44272
+    df = DataFrame([[1, 2, 3, 4, 5]])
+    with option_context("styler.render.max_columns", 2):
+        ctx = df.style.hide([0, 1], axis="columns")._translate(True, True)
+
+    assert len(ctx["head"][0]) == 6  # blank, [0, 1 (hidden)], [2 ,3 (visible)], + trim
+    for c, vals in enumerate([(1, False), (2, True), (3, True), ("...", True)]):
+        assert ctx["head"][0][c + 2]["value"] == vals[0]
+        assert ctx["head"][0][c + 2]["is_visible"] == vals[1]
+
+    assert len(ctx["body"][0]) == 6  # index + 2 hidden + 2 visible + trimming col
+
+
+def test_no_empty_apply(mi_styler):
+    # 45313
+    mi_styler.apply(lambda s: ["a:v;"] * 2, subset=[False, False])
+    mi_styler._compute()
+
+
+@pytest.mark.parametrize("format", ["html", "latex", "string"])
+def test_output_buffer(mi_styler, format):
+    # gh 47053
+    with tm.ensure_clean(f"delete_me.{format}") as f:
+        getattr(mi_styler, f"to_{format}")(f)

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_to_latex.py

@@ -0,0 +1,1090 @@
+from textwrap import dedent
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    option_context,
+)
+
+pytest.importorskip("jinja2")
+from pandas.io.formats.style import Styler
+from pandas.io.formats.style_render import (
+    _parse_latex_cell_styles,
+    _parse_latex_css_conversion,
+    _parse_latex_header_span,
+    _parse_latex_table_styles,
+    _parse_latex_table_wrapping,
+)
+
+
+@pytest.fixture
+def df():
+    return DataFrame(
+        {"A": [0, 1], "B": [-0.61, -1.22], "C": Series(["ab", "cd"], dtype=object)}
+    )
+
+
+@pytest.fixture
+def df_ext():
+    return DataFrame(
+        {"A": [0, 1, 2], "B": [-0.61, -1.22, -2.22], "C": ["ab", "cd", "de"]}
+    )
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0, precision=2)
+
+
+def test_minimal_latex_tabular(styler):
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+         & A & B & C \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex() == expected
+
+
+def test_tabular_hrules(styler):
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+        \\toprule
+         & A & B & C \\\\
+        \\midrule
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\bottomrule
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex(hrules=True) == expected
+
+
+def test_tabular_custom_hrules(styler):
+    styler.set_table_styles(
+        [
+            {"selector": "toprule", "props": ":hline"},
+            {"selector": "bottomrule", "props": ":otherline"},
+        ]
+    )  # no midrule
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+        \\hline
+         & A & B & C \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\otherline
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex() == expected
+
+
+def test_column_format(styler):
+    # default setting is already tested in `test_latex_minimal_tabular`
+    styler.set_table_styles([{"selector": "column_format", "props": ":cccc"}])
+
+    assert "\\begin{tabular}{rrrr}" in styler.to_latex(column_format="rrrr")
+    styler.set_table_styles([{"selector": "column_format", "props": ":r|r|cc"}])
+    assert "\\begin{tabular}{r|r|cc}" in styler.to_latex()
+
+
+def test_siunitx_cols(styler):
+    expected = dedent(
+        """\
+        \\begin{tabular}{lSSl}
+        {} & {A} & {B} & {C} \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex(siunitx=True) == expected
+
+
+def test_position(styler):
+    assert "\\begin{table}[h!]" in styler.to_latex(position="h!")
+    assert "\\end{table}" in styler.to_latex(position="h!")
+    styler.set_table_styles([{"selector": "position", "props": ":b!"}])
+    assert "\\begin{table}[b!]" in styler.to_latex()
+    assert "\\end{table}" in styler.to_latex()
+
+
+@pytest.mark.parametrize("env", [None, "longtable"])
+def test_label(styler, env):
+    assert "\n\\label{text}" in styler.to_latex(label="text", environment=env)
+    styler.set_table_styles([{"selector": "label", "props": ":{more §text}"}])
+    assert "\n\\label{more :text}" in styler.to_latex(environment=env)
+
+
+def test_position_float_raises(styler):
+    msg = "`position_float` should be one of 'raggedright', 'raggedleft', 'centering',"
+    with pytest.raises(ValueError, match=msg):
+        styler.to_latex(position_float="bad_string")
+
+    msg = "`position_float` cannot be used in 'longtable' `environment`"
+    with pytest.raises(ValueError, match=msg):
+        styler.to_latex(position_float="centering", environment="longtable")
+
+
+@pytest.mark.parametrize("label", [(None, ""), ("text", "\\label{text}")])
+@pytest.mark.parametrize("position", [(None, ""), ("h!", "{table}[h!]")])
+@pytest.mark.parametrize("caption", [(None, ""), ("text", "\\caption{text}")])
+@pytest.mark.parametrize("column_format", [(None, ""), ("rcrl", "{tabular}{rcrl}")])
+@pytest.mark.parametrize("position_float", [(None, ""), ("centering", "\\centering")])
+def test_kwargs_combinations(
+    styler, label, position, caption, column_format, position_float
+):
+    result = styler.to_latex(
+        label=label[0],
+        position=position[0],
+        caption=caption[0],
+        column_format=column_format[0],
+        position_float=position_float[0],
+    )
+    assert label[1] in result
+    assert position[1] in result
+    assert caption[1] in result
+    assert column_format[1] in result
+    assert position_float[1] in result
+
+
+def test_custom_table_styles(styler):
+    styler.set_table_styles(
+        [
+            {"selector": "mycommand", "props": ":{myoptions}"},
+            {"selector": "mycommand2", "props": ":{myoptions2}"},
+        ]
+    )
+    expected = dedent(
+        """\
+        \\begin{table}
+        \\mycommand{myoptions}
+        \\mycommand2{myoptions2}
+        """
+    )
+    assert expected in styler.to_latex()
+
+
+def test_cell_styling(styler):
+    styler.highlight_max(props="itshape:;Huge:--wrap;")
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+         & A & B & C \\\\
+        0 & 0 & \\itshape {\\Huge -0.61} & ab \\\\
+        1 & \\itshape {\\Huge 1} & -1.22 & \\itshape {\\Huge cd} \\\\
+        \\end{tabular}
+        """
+    )
+    assert expected == styler.to_latex()
+
+
+def test_multiindex_columns(df):
+    cidx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df.columns = cidx
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+         & \\multicolumn{2}{r}{A} & B \\\\
+         & a & b & c \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    s = df.style.format(precision=2)
+    assert expected == s.to_latex()
+
+    # non-sparse
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+         & A & A & B \\\\
+         & a & b & c \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    s = df.style.format(precision=2)
+    assert expected == s.to_latex(sparse_columns=False)
+
+
+def test_multiindex_row(df_ext):
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df_ext.index = ridx
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrl}
+         &  & A & B & C \\\\
+        \\multirow[c]{2}{*}{A} & a & 0 & -0.61 & ab \\\\
+         & b & 1 & -1.22 & cd \\\\
+        B & c & 2 & -2.22 & de \\\\
+        \\end{tabular}
+        """
+    )
+    styler = df_ext.style.format(precision=2)
+    result = styler.to_latex()
+    assert expected == result
+
+    # non-sparse
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrl}
+         &  & A & B & C \\\\
+        A & a & 0 & -0.61 & ab \\\\
+        A & b & 1 & -1.22 & cd \\\\
+        B & c & 2 & -2.22 & de \\\\
+        \\end{tabular}
+        """
+    )
+    result = styler.to_latex(sparse_index=False)
+    assert expected == result
+
+
+def test_multirow_naive(df_ext):
+    ridx = MultiIndex.from_tuples([("X", "x"), ("X", "y"), ("Y", "z")])
+    df_ext.index = ridx
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrl}
+         &  & A & B & C \\\\
+        X & x & 0 & -0.61 & ab \\\\
+         & y & 1 & -1.22 & cd \\\\
+        Y & z & 2 & -2.22 & de \\\\
+        \\end{tabular}
+        """
+    )
+    styler = df_ext.style.format(precision=2)
+    result = styler.to_latex(multirow_align="naive")
+    assert expected == result
+
+
+def test_multiindex_row_and_col(df_ext):
+    cidx = MultiIndex.from_tuples([("Z", "a"), ("Z", "b"), ("Y", "c")])
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df_ext.index, df_ext.columns = ridx, cidx
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrl}
+         &  & \\multicolumn{2}{l}{Z} & Y \\\\
+         &  & a & b & c \\\\
+        \\multirow[b]{2}{*}{A} & a & 0 & -0.61 & ab \\\\
+         & b & 1 & -1.22 & cd \\\\
+        B & c & 2 & -2.22 & de \\\\
+        \\end{tabular}
+        """
+    )
+    styler = df_ext.style.format(precision=2)
+    result = styler.to_latex(multirow_align="b", multicol_align="l")
+    assert result == expected
+
+    # non-sparse
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrl}
+         &  & Z & Z & Y \\\\
+         &  & a & b & c \\\\
+        A & a & 0 & -0.61 & ab \\\\
+        A & b & 1 & -1.22 & cd \\\\
+        B & c & 2 & -2.22 & de \\\\
+        \\end{tabular}
+        """
+    )
+    result = styler.to_latex(sparse_index=False, sparse_columns=False)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "multicol_align, siunitx, header",
+    [
+        ("naive-l", False, " & A & &"),
+        ("naive-r", False, " & & & A"),
+        ("naive-l", True, "{} & {A} & {} & {}"),
+        ("naive-r", True, "{} & {} & {} & {A}"),
+    ],
+)
+def test_multicol_naive(df, multicol_align, siunitx, header):
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("A", "c")])
+    df.columns = ridx
+    level1 = " & a & b & c" if not siunitx else "{} & {a} & {b} & {c}"
+    col_format = "lrrl" if not siunitx else "lSSl"
+    expected = dedent(
+        f"""\
+        \\begin{{tabular}}{{{col_format}}}
+        {header} \\\\
+        {level1} \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{{tabular}}
+        """
+    )
+    styler = df.style.format(precision=2)
+    result = styler.to_latex(multicol_align=multicol_align, siunitx=siunitx)
+    assert expected == result
+
+
+def test_multi_options(df_ext):
+    cidx = MultiIndex.from_tuples([("Z", "a"), ("Z", "b"), ("Y", "c")])
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df_ext.index, df_ext.columns = ridx, cidx
+    styler = df_ext.style.format(precision=2)
+
+    expected = dedent(
+        """\
+     &  & \\multicolumn{2}{r}{Z} & Y \\\\
+     &  & a & b & c \\\\
+    \\multirow[c]{2}{*}{A} & a & 0 & -0.61 & ab \\\\
+    """
+    )
+    result = styler.to_latex()
+    assert expected in result
+
+    with option_context("styler.latex.multicol_align", "l"):
+        assert " &  & \\multicolumn{2}{l}{Z} & Y \\\\" in styler.to_latex()
+
+    with option_context("styler.latex.multirow_align", "b"):
+        assert "\\multirow[b]{2}{*}{A} & a & 0 & -0.61 & ab \\\\" in styler.to_latex()
+
+
+def test_multiindex_columns_hidden():
+    df = DataFrame([[1, 2, 3, 4]])
+    df.columns = MultiIndex.from_tuples([("A", 1), ("A", 2), ("A", 3), ("B", 1)])
+    s = df.style
+    assert "{tabular}{lrrrr}" in s.to_latex()
+    s.set_table_styles([])  # reset the position command
+    s.hide([("A", 2)], axis="columns")
+    assert "{tabular}{lrrr}" in s.to_latex()
+
+
+@pytest.mark.parametrize(
+    "option, value",
+    [
+        ("styler.sparse.index", True),
+        ("styler.sparse.index", False),
+        ("styler.sparse.columns", True),
+        ("styler.sparse.columns", False),
+    ],
+)
+def test_sparse_options(df_ext, option, value):
+    cidx = MultiIndex.from_tuples([("Z", "a"), ("Z", "b"), ("Y", "c")])
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df_ext.index, df_ext.columns = ridx, cidx
+    styler = df_ext.style
+
+    latex1 = styler.to_latex()
+    with option_context(option, value):
+        latex2 = styler.to_latex()
+    assert (latex1 == latex2) is value
+
+
+def test_hidden_index(styler):
+    styler.hide(axis="index")
+    expected = dedent(
+        """\
+        \\begin{tabular}{rrl}
+        A & B & C \\\\
+        0 & -0.61 & ab \\\\
+        1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex() == expected
+
+
+@pytest.mark.parametrize("environment", ["table", "figure*", None])
+def test_comprehensive(df_ext, environment):
+    # test as many low level features simultaneously as possible
+    cidx = MultiIndex.from_tuples([("Z", "a"), ("Z", "b"), ("Y", "c")])
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df_ext.index, df_ext.columns = ridx, cidx
+    stlr = df_ext.style
+    stlr.set_caption("mycap")
+    stlr.set_table_styles(
+        [
+            {"selector": "label", "props": ":{fig§item}"},
+            {"selector": "position", "props": ":h!"},
+            {"selector": "position_float", "props": ":centering"},
+            {"selector": "column_format", "props": ":rlrlr"},
+            {"selector": "toprule", "props": ":toprule"},
+            {"selector": "midrule", "props": ":midrule"},
+            {"selector": "bottomrule", "props": ":bottomrule"},
+            {"selector": "rowcolors", "props": ":{3}{pink}{}"},  # custom command
+        ]
+    )
+    stlr.highlight_max(axis=0, props="textbf:--rwrap;cellcolor:[rgb]{1,1,0.6}--rwrap")
+    stlr.highlight_max(axis=None, props="Huge:--wrap;", subset=[("Z", "a"), ("Z", "b")])
+
+    expected = (
+        """\
+\\begin{table}[h!]
+\\centering
+\\caption{mycap}
+\\label{fig:item}
+\\rowcolors{3}{pink}{}
+\\begin{tabular}{rlrlr}
+\\toprule
+ &  & \\multicolumn{2}{r}{Z} & Y \\\\
+ &  & a & b & c \\\\
+\\midrule
+\\multirow[c]{2}{*}{A} & a & 0 & \\textbf{\\cellcolor[rgb]{1,1,0.6}{-0.61}} & ab \\\\
+ & b & 1 & -1.22 & cd \\\\
+B & c & \\textbf{\\cellcolor[rgb]{1,1,0.6}{{\\Huge 2}}} & -2.22 & """
+        """\
+\\textbf{\\cellcolor[rgb]{1,1,0.6}{de}} \\\\
+\\bottomrule
+\\end{tabular}
+\\end{table}
+"""
+    ).replace("table", environment if environment else "table")
+    result = stlr.format(precision=2).to_latex(environment=environment)
+    assert result == expected
+
+
+def test_environment_option(styler):
+    with option_context("styler.latex.environment", "bar-env"):
+        assert "\\begin{bar-env}" in styler.to_latex()
+        assert "\\begin{foo-env}" in styler.to_latex(environment="foo-env")
+
+
+def test_parse_latex_table_styles(styler):
+    styler.set_table_styles(
+        [
+            {"selector": "foo", "props": [("attr", "value")]},
+            {"selector": "bar", "props": [("attr", "overwritten")]},
+            {"selector": "bar", "props": [("attr", "baz"), ("attr2", "ignored")]},
+            {"selector": "label", "props": [("", "{fig§item}")]},
+        ]
+    )
+    assert _parse_latex_table_styles(styler.table_styles, "bar") == "baz"
+
+    # test '§' replaced by ':' [for CSS compatibility]
+    assert _parse_latex_table_styles(styler.table_styles, "label") == "{fig:item}"
+
+
+def test_parse_latex_cell_styles_basic():  # test nesting
+    cell_style = [("itshape", "--rwrap"), ("cellcolor", "[rgb]{0,1,1}--rwrap")]
+    expected = "\\itshape{\\cellcolor[rgb]{0,1,1}{text}}"
+    assert _parse_latex_cell_styles(cell_style, "text") == expected
+
+
+@pytest.mark.parametrize(
+    "wrap_arg, expected",
+    [  # test wrapping
+        ("", "\\<command><options> <display_value>"),
+        ("--wrap", "{\\<command><options> <display_value>}"),
+        ("--nowrap", "\\<command><options> <display_value>"),
+        ("--lwrap", "{\\<command><options>} <display_value>"),
+        ("--dwrap", "{\\<command><options>}{<display_value>}"),
+        ("--rwrap", "\\<command><options>{<display_value>}"),
+    ],
+)
+def test_parse_latex_cell_styles_braces(wrap_arg, expected):
+    cell_style = [("<command>", f"<options>{wrap_arg}")]
+    assert _parse_latex_cell_styles(cell_style, "<display_value>") == expected
+
+
+def test_parse_latex_header_span():
+    cell = {"attributes": 'colspan="3"', "display_value": "text", "cellstyle": []}
+    expected = "\\multicolumn{3}{Y}{text}"
+    assert _parse_latex_header_span(cell, "X", "Y") == expected
+
+    cell = {"attributes": 'rowspan="5"', "display_value": "text", "cellstyle": []}
+    expected = "\\multirow[X]{5}{*}{text}"
+    assert _parse_latex_header_span(cell, "X", "Y") == expected
+
+    cell = {"display_value": "text", "cellstyle": []}
+    assert _parse_latex_header_span(cell, "X", "Y") == "text"
+
+    cell = {"display_value": "text", "cellstyle": [("bfseries", "--rwrap")]}
+    assert _parse_latex_header_span(cell, "X", "Y") == "\\bfseries{text}"
+
+
+def test_parse_latex_table_wrapping(styler):
+    styler.set_table_styles(
+        [
+            {"selector": "toprule", "props": ":value"},
+            {"selector": "bottomrule", "props": ":value"},
+            {"selector": "midrule", "props": ":value"},
+            {"selector": "column_format", "props": ":value"},
+        ]
+    )
+    assert _parse_latex_table_wrapping(styler.table_styles, styler.caption) is False
+    assert _parse_latex_table_wrapping(styler.table_styles, "some caption") is True
+    styler.set_table_styles(
+        [
+            {"selector": "not-ignored", "props": ":value"},
+        ],
+        overwrite=False,
+    )
+    assert _parse_latex_table_wrapping(styler.table_styles, None) is True
+
+
+def test_short_caption(styler):
+    result = styler.to_latex(caption=("full cap", "short cap"))
+    assert "\\caption[short cap]{full cap}" in result
+
+
+@pytest.mark.parametrize(
+    "css, expected",
+    [
+        ([("color", "red")], [("color", "{red}")]),  # test color and input format types
+        (
+            [("color", "rgb(128, 128, 128 )")],
+            [("color", "[rgb]{0.502, 0.502, 0.502}")],
+        ),
+        (
+            [("color", "rgb(128, 50%, 25% )")],
+            [("color", "[rgb]{0.502, 0.500, 0.250}")],
+        ),
+        (
+            [("color", "rgba(128,128,128,1)")],
+            [("color", "[rgb]{0.502, 0.502, 0.502}")],
+        ),
+        ([("color", "#FF00FF")], [("color", "[HTML]{FF00FF}")]),
+        ([("color", "#F0F")], [("color", "[HTML]{FF00FF}")]),
+        ([("font-weight", "bold")], [("bfseries", "")]),  # test font-weight and types
+        ([("font-weight", "bolder")], [("bfseries", "")]),
+        ([("font-weight", "normal")], []),
+        ([("background-color", "red")], [("cellcolor", "{red}--lwrap")]),
+        (
+            [("background-color", "#FF00FF")],  # test background-color command and wrap
+            [("cellcolor", "[HTML]{FF00FF}--lwrap")],
+        ),
+        ([("font-style", "italic")], [("itshape", "")]),  # test font-style and types
+        ([("font-style", "oblique")], [("slshape", "")]),
+        ([("font-style", "normal")], []),
+        ([("color", "red /*--dwrap*/")], [("color", "{red}--dwrap")]),  # css comments
+        ([("background-color", "red /* --dwrap */")], [("cellcolor", "{red}--dwrap")]),
+    ],
+)
+def test_parse_latex_css_conversion(css, expected):
+    result = _parse_latex_css_conversion(css)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "env, inner_env",
+    [
+        (None, "tabular"),
+        ("table", "tabular"),
+        ("longtable", "longtable"),
+    ],
+)
+@pytest.mark.parametrize(
+    "convert, exp", [(True, "bfseries"), (False, "font-weightbold")]
+)
+def test_parse_latex_css_convert_minimal(styler, env, inner_env, convert, exp):
+    # parameters ensure longtable template is also tested
+    styler.highlight_max(props="font-weight:bold;")
+    result = styler.to_latex(convert_css=convert, environment=env)
+    expected = dedent(
+        f"""\
+        0 & 0 & \\{exp} -0.61 & ab \\\\
+        1 & \\{exp} 1 & -1.22 & \\{exp} cd \\\\
+        \\end{{{inner_env}}}
+    """
+    )
+    assert expected in result
+
+
+def test_parse_latex_css_conversion_option():
+    css = [("command", "option--latex--wrap")]
+    expected = [("command", "option--wrap")]
+    result = _parse_latex_css_conversion(css)
+    assert result == expected
+
+
+def test_styler_object_after_render(styler):
+    # GH 42320
+    pre_render = styler._copy(deepcopy=True)
+    styler.to_latex(
+        column_format="rllr",
+        position="h",
+        position_float="centering",
+        hrules=True,
+        label="my lab",
+        caption="my cap",
+    )
+
+    assert pre_render.table_styles == styler.table_styles
+    assert pre_render.caption == styler.caption
+
+
+def test_longtable_comprehensive(styler):
+    result = styler.to_latex(
+        environment="longtable", hrules=True, label="fig:A", caption=("full", "short")
+    )
+    expected = dedent(
+        """\
+        \\begin{longtable}{lrrl}
+        \\caption[short]{full} \\label{fig:A} \\\\
+        \\toprule
+         & A & B & C \\\\
+        \\midrule
+        \\endfirsthead
+        \\caption[]{full} \\\\
+        \\toprule
+         & A & B & C \\\\
+        \\midrule
+        \\endhead
+        \\midrule
+        \\multicolumn{4}{r}{Continued on next page} \\\\
+        \\midrule
+        \\endfoot
+        \\bottomrule
+        \\endlastfoot
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{longtable}
+    """
+    )
+    assert result == expected
+
+
+def test_longtable_minimal(styler):
+    result = styler.to_latex(environment="longtable")
+    expected = dedent(
+        """\
+        \\begin{longtable}{lrrl}
+         & A & B & C \\\\
+        \\endfirsthead
+         & A & B & C \\\\
+        \\endhead
+        \\multicolumn{4}{r}{Continued on next page} \\\\
+        \\endfoot
+        \\endlastfoot
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{longtable}
+    """
+    )
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "sparse, exp, siunitx",
+    [
+        (True, "{} & \\multicolumn{2}{r}{A} & {B}", True),
+        (False, "{} & {A} & {A} & {B}", True),
+        (True, " & \\multicolumn{2}{r}{A} & B", False),
+        (False, " & A & A & B", False),
+    ],
+)
+def test_longtable_multiindex_columns(df, sparse, exp, siunitx):
+    cidx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df.columns = cidx
+    with_si = "{} & {a} & {b} & {c} \\\\"
+    without_si = " & a & b & c \\\\"
+    expected = dedent(
+        f"""\
+        \\begin{{longtable}}{{l{"SS" if siunitx else "rr"}l}}
+        {exp} \\\\
+        {with_si if siunitx else without_si}
+        \\endfirsthead
+        {exp} \\\\
+        {with_si if siunitx else without_si}
+        \\endhead
+        """
+    )
+    result = df.style.to_latex(
+        environment="longtable", sparse_columns=sparse, siunitx=siunitx
+    )
+    assert expected in result
+
+
+@pytest.mark.parametrize(
+    "caption, cap_exp",
+    [
+        ("full", ("{full}", "")),
+        (("full", "short"), ("{full}", "[short]")),
+    ],
+)
+@pytest.mark.parametrize("label, lab_exp", [(None, ""), ("tab:A", " \\label{tab:A}")])
+def test_longtable_caption_label(styler, caption, cap_exp, label, lab_exp):
+    cap_exp1 = f"\\caption{cap_exp[1]}{cap_exp[0]}"
+    cap_exp2 = f"\\caption[]{cap_exp[0]}"
+
+    expected = dedent(
+        f"""\
+        {cap_exp1}{lab_exp} \\\\
+         & A & B & C \\\\
+        \\endfirsthead
+        {cap_exp2} \\\\
+        """
+    )
+    assert expected in styler.to_latex(
+        environment="longtable", caption=caption, label=label
+    )
+
+
+@pytest.mark.parametrize("index", [True, False])
+@pytest.mark.parametrize(
+    "columns, siunitx",
+    [
+        (True, True),
+        (True, False),
+        (False, False),
+    ],
+)
+def test_apply_map_header_render_mi(df_ext, index, columns, siunitx):
+    cidx = MultiIndex.from_tuples([("Z", "a"), ("Z", "b"), ("Y", "c")])
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df_ext.index, df_ext.columns = ridx, cidx
+    styler = df_ext.style
+
+    func = lambda v: "bfseries: --rwrap" if "A" in v or "Z" in v or "c" in v else None
+
+    if index:
+        styler.map_index(func, axis="index")
+    if columns:
+        styler.map_index(func, axis="columns")
+
+    result = styler.to_latex(siunitx=siunitx)
+
+    expected_index = dedent(
+        """\
+    \\multirow[c]{2}{*}{\\bfseries{A}} & a & 0 & -0.610000 & ab \\\\
+    \\bfseries{} & b & 1 & -1.220000 & cd \\\\
+    B & \\bfseries{c} & 2 & -2.220000 & de \\\\
+    """
+    )
+    assert (expected_index in result) is index
+
+    exp_cols_si = dedent(
+        """\
+    {} & {} & \\multicolumn{2}{r}{\\bfseries{Z}} & {Y} \\\\
+    {} & {} & {a} & {b} & {\\bfseries{c}} \\\\
+    """
+    )
+    exp_cols_no_si = """\
+ &  & \\multicolumn{2}{r}{\\bfseries{Z}} & Y \\\\
+ &  & a & b & \\bfseries{c} \\\\
+"""
+    assert ((exp_cols_si if siunitx else exp_cols_no_si) in result) is columns
+
+
+def test_repr_option(styler):
+    assert "<style" in styler._repr_html_()[:6]
+    assert styler._repr_latex_() is None
+    with option_context("styler.render.repr", "latex"):
+        assert "\\begin{tabular}" in styler._repr_latex_()[:15]
+        assert styler._repr_html_() is None
+
+
+@pytest.mark.parametrize("option", ["hrules"])
+def test_bool_options(styler, option):
+    with option_context(f"styler.latex.{option}", False):
+        latex_false = styler.to_latex()
+    with option_context(f"styler.latex.{option}", True):
+        latex_true = styler.to_latex()
+    assert latex_false != latex_true  # options are reactive under to_latex(*no_args)
+
+
+def test_siunitx_basic_headers(styler):
+    assert "{} & {A} & {B} & {C} \\\\" in styler.to_latex(siunitx=True)
+    assert " & A & B & C \\\\" in styler.to_latex()  # default siunitx=False
+
+
+@pytest.mark.parametrize("axis", ["index", "columns"])
+def test_css_convert_apply_index(styler, axis):
+    styler.map_index(lambda x: "font-weight: bold;", axis=axis)
+    for label in getattr(styler, axis):
+        assert f"\\bfseries {label}" in styler.to_latex(convert_css=True)
+
+
+def test_hide_index_latex(styler):
+    # GH 43637
+    styler.hide([0], axis=0)
+    result = styler.to_latex()
+    expected = dedent(
+        """\
+    \\begin{tabular}{lrrl}
+     & A & B & C \\\\
+    1 & 1 & -1.22 & cd \\\\
+    \\end{tabular}
+    """
+    )
+    assert expected == result
+
+
+def test_latex_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(level=1, axis=0).hide(level=0, axis=1)
+    styler.hide([("i0", "i1", "i2")], axis=0)
+    styler.hide([("c0", "c1", "c2")], axis=1)
+    styler.map(lambda x: "color:{red};" if x == 5 else "")
+    styler.map_index(lambda x: "color:{blue};" if "j" in x else "")
+    result = styler.to_latex()
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrr}
+         & c-1 & c1 & \\multicolumn{2}{r}{d1} \\\\
+         & c-2 & d2 & c2 & d2 \\\\
+        i-0 & i-2 &  &  &  \\\\
+        i0 & \\color{blue} j2 & \\color{red} 5 & 6 & 7 \\\\
+        \\multirow[c]{2}{*}{\\color{blue} j0} & i2 & 9 & 10 & 11 \\\\
+        \\color{blue}  & \\color{blue} j2 & 13 & 14 & 15 \\\\
+        \\end{tabular}
+        """
+    )
+    assert result == expected
+
+
+def test_rendered_links():
+    # note the majority of testing is done in test_html.py: test_rendered_links
+    # these test only the alternative latex format is functional
+    df = DataFrame(["text www.domain.com text"])
+    result = df.style.format(hyperlinks="latex").to_latex()
+    assert r"text \href{www.domain.com}{www.domain.com} text" in result
+
+
+def test_apply_index_hidden_levels():
+    # gh 45156
+    styler = DataFrame(
+        [[1]],
+        index=MultiIndex.from_tuples([(0, 1)], names=["l0", "l1"]),
+        columns=MultiIndex.from_tuples([(0, 1)], names=["c0", "c1"]),
+    ).style
+    styler.hide(level=1)
+    styler.map_index(lambda v: "color: red;", level=0, axis=1)
+    result = styler.to_latex(convert_css=True)
+    expected = dedent(
+        """\
+        \\begin{tabular}{lr}
+        c0 & \\color{red} 0 \\\\
+        c1 & 1 \\\\
+        l0 &  \\\\
+        0 & 1 \\\\
+        \\end{tabular}
+        """
+    )
+    assert result == expected
+
+
+@pytest.mark.parametrize("clines", ["bad", "index", "skip-last", "all", "data"])
+def test_clines_validation(clines, styler):
+    msg = f"`clines` value of {clines} is invalid."
+    with pytest.raises(ValueError, match=msg):
+        styler.to_latex(clines=clines)
+
+
+@pytest.mark.parametrize(
+    "clines, exp",
+    [
+        ("all;index", "\n\\cline{1-1}"),
+        ("all;data", "\n\\cline{1-2}"),
+        ("skip-last;index", ""),
+        ("skip-last;data", ""),
+        (None, ""),
+    ],
+)
+@pytest.mark.parametrize("env", ["table", "longtable"])
+def test_clines_index(clines, exp, env):
+    df = DataFrame([[1], [2], [3], [4]])
+    result = df.style.to_latex(clines=clines, environment=env)
+    expected = f"""\
+0 & 1 \\\\{exp}
+1 & 2 \\\\{exp}
+2 & 3 \\\\{exp}
+3 & 4 \\\\{exp}
+"""
+    assert expected in result
+
+
+@pytest.mark.parametrize(
+    "clines, expected",
+    [
+        (
+            None,
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+             & Y & 2 \\\\
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+             & Y & 4 \\\\
+            """
+            ),
+        ),
+        (
+            "skip-last;index",
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+             & Y & 2 \\\\
+            \\cline{1-2}
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+             & Y & 4 \\\\
+            \\cline{1-2}
+            """
+            ),
+        ),
+        (
+            "skip-last;data",
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+             & Y & 2 \\\\
+            \\cline{1-3}
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+             & Y & 4 \\\\
+            \\cline{1-3}
+            """
+            ),
+        ),
+        (
+            "all;index",
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+            \\cline{2-2}
+             & Y & 2 \\\\
+            \\cline{1-2} \\cline{2-2}
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+            \\cline{2-2}
+             & Y & 4 \\\\
+            \\cline{1-2} \\cline{2-2}
+            """
+            ),
+        ),
+        (
+            "all;data",
+            dedent(
+                """\
+            \\multirow[c]{2}{*}{A} & X & 1 \\\\
+            \\cline{2-3}
+             & Y & 2 \\\\
+            \\cline{1-3} \\cline{2-3}
+            \\multirow[c]{2}{*}{B} & X & 3 \\\\
+            \\cline{2-3}
+             & Y & 4 \\\\
+            \\cline{1-3} \\cline{2-3}
+            """
+            ),
+        ),
+    ],
+)
+@pytest.mark.parametrize("env", ["table"])
+def test_clines_multiindex(clines, expected, env):
+    # also tests simultaneously with hidden rows and a hidden multiindex level
+    midx = MultiIndex.from_product([["A", "-", "B"], [0], ["X", "Y"]])
+    df = DataFrame([[1], [2], [99], [99], [3], [4]], index=midx)
+    styler = df.style
+    styler.hide([("-", 0, "X"), ("-", 0, "Y")])
+    styler.hide(level=1)
+    result = styler.to_latex(clines=clines, environment=env)
+    assert expected in result
+
+
+def test_col_format_len(styler):
+    # gh 46037
+    result = styler.to_latex(environment="longtable", column_format="lrr{10cm}")
+    expected = r"\multicolumn{4}{r}{Continued on next page} \\"
+    assert expected in result
+
+
+def test_concat(styler):
+    result = styler.concat(styler.data.agg(["sum"]).style).to_latex()
+    expected = dedent(
+        """\
+    \\begin{tabular}{lrrl}
+     & A & B & C \\\\
+    0 & 0 & -0.61 & ab \\\\
+    1 & 1 & -1.22 & cd \\\\
+    sum & 1 & -1.830000 & abcd \\\\
+    \\end{tabular}
+    """
+    )
+    assert result == expected
+
+
+def test_concat_recursion():
+    # tests hidden row recursion and applied styles
+    styler1 = DataFrame([[1], [9]]).style.hide([1]).highlight_min(color="red")
+    styler2 = DataFrame([[9], [2]]).style.hide([0]).highlight_min(color="green")
+    styler3 = DataFrame([[3], [9]]).style.hide([1]).highlight_min(color="blue")
+
+    result = styler1.concat(styler2.concat(styler3)).to_latex(convert_css=True)
+    expected = dedent(
+        """\
+    \\begin{tabular}{lr}
+     & 0 \\\\
+    0 & {\\cellcolor{red}} 1 \\\\
+    1 & {\\cellcolor{green}} 2 \\\\
+    0 & {\\cellcolor{blue}} 3 \\\\
+    \\end{tabular}
+    """
+    )
+    assert result == expected
+
+
+def test_concat_chain():
+    # tests hidden row recursion and applied styles
+    styler1 = DataFrame([[1], [9]]).style.hide([1]).highlight_min(color="red")
+    styler2 = DataFrame([[9], [2]]).style.hide([0]).highlight_min(color="green")
+    styler3 = DataFrame([[3], [9]]).style.hide([1]).highlight_min(color="blue")
+
+    result = styler1.concat(styler2).concat(styler3).to_latex(convert_css=True)
+    expected = dedent(
+        """\
+    \\begin{tabular}{lr}
+     & 0 \\\\
+    0 & {\\cellcolor{red}} 1 \\\\
+    1 & {\\cellcolor{green}} 2 \\\\
+    0 & {\\cellcolor{blue}} 3 \\\\
+    \\end{tabular}
+    """
+    )
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "df, expected",
+    [
+        (
+            DataFrame(),
+            dedent(
+                """\
+            \\begin{tabular}{l}
+            \\end{tabular}
+            """
+            ),
+        ),
+        (
+            DataFrame(columns=["a", "b", "c"]),
+            dedent(
+                """\
+            \\begin{tabular}{llll}
+             & a & b & c \\\\
+            \\end{tabular}
+            """
+            ),
+        ),
+    ],
+)
+@pytest.mark.parametrize(
+    "clines", [None, "all;data", "all;index", "skip-last;data", "skip-last;index"]
+)
+def test_empty_clines(df: DataFrame, expected: str, clines: str):
+    # GH 47203
+    result = df.style.to_latex(clines=clines)
+    assert result == expected

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_to_string.py

@@ -0,0 +1,96 @@
+from textwrap import dedent
+
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+
+pytest.importorskip("jinja2")
+from pandas.io.formats.style import Styler
+
+
+@pytest.fixture
+def df():
+    return DataFrame(
+        {"A": [0, 1], "B": [-0.61, -1.22], "C": Series(["ab", "cd"], dtype=object)}
+    )
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0, precision=2)
+
+
+def test_basic_string(styler):
+    result = styler.to_string()
+    expected = dedent(
+        """\
+     A B C
+    0 0 -0.61 ab
+    1 1 -1.22 cd
+    """
+    )
+    assert result == expected
+
+
+def test_string_delimiter(styler):
+    result = styler.to_string(delimiter=";")
+    expected = dedent(
+        """\
+    ;A;B;C
+    0;0;-0.61;ab
+    1;1;-1.22;cd
+    """
+    )
+    assert result == expected
+
+
+def test_concat(styler):
+    result = styler.concat(styler.data.agg(["sum"]).style).to_string()
+    expected = dedent(
+        """\
+     A B C
+    0 0 -0.61 ab
+    1 1 -1.22 cd
+    sum 1 -1.830000 abcd
+    """
+    )
+    assert result == expected
+
+
+def test_concat_recursion(styler):
+    df = styler.data
+    styler1 = styler
+    styler2 = Styler(df.agg(["sum"]), uuid_len=0, precision=3)
+    styler3 = Styler(df.agg(["sum"]), uuid_len=0, precision=4)
+    result = styler1.concat(styler2.concat(styler3)).to_string()
+    expected = dedent(
+        """\
+     A B C
+    0 0 -0.61 ab
+    1 1 -1.22 cd
+    sum 1 -1.830 abcd
+    sum 1 -1.8300 abcd
+    """
+    )
+    assert result == expected
+
+
+def test_concat_chain(styler):
+    df = styler.data
+    styler1 = styler
+    styler2 = Styler(df.agg(["sum"]), uuid_len=0, precision=3)
+    styler3 = Styler(df.agg(["sum"]), uuid_len=0, precision=4)
+    result = styler1.concat(styler2).concat(styler3).to_string()
+    expected = dedent(
+        """\
+     A B C
+    0 0 -0.61 ab
+    1 1 -1.22 cd
+    sum 1 -1.830 abcd
+    sum 1 -1.8300 abcd
+    """
+    )
+    assert result == expected

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/style/test_tooltip.py

@@ -0,0 +1,85 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+
+pytest.importorskip("jinja2")
+from pandas.io.formats.style import Styler
+
+
+@pytest.fixture
+def df():
+    return DataFrame(
+        data=[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
+        columns=["A", "B", "C"],
+        index=["x", "y", "z"],
+    )
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0)
+
+
+@pytest.mark.parametrize(
+    "ttips",
+    [
+        DataFrame(  # Test basic reindex and ignoring blank
+            data=[["Min", "Max"], [np.nan, ""]],
+            columns=["A", "C"],
+            index=["x", "y"],
+        ),
+        DataFrame(  # Test non-referenced columns, reversed col names, short index
+            data=[["Max", "Min", "Bad-Col"]], columns=["C", "A", "D"], index=["x"]
+        ),
+    ],
+)
+def test_tooltip_render(ttips, styler):
+    # GH 21266
+    result = styler.set_tooltips(ttips).to_html()
+
+    # test tooltip table level class
+    assert "#T_ .pd-t {\n  visibility: hidden;\n" in result
+
+    # test 'Min' tooltip added
+    assert "#T_ #T__row0_col0:hover .pd-t {\n  visibility: visible;\n}" in result
+    assert '#T_ #T__row0_col0 .pd-t::after {\n  content: "Min";\n}' in result
+    assert 'class="data row0 col0" >0<span class="pd-t"></span></td>' in result
+
+    # test 'Max' tooltip added
+    assert "#T_ #T__row0_col2:hover .pd-t {\n  visibility: visible;\n}" in result
+    assert '#T_ #T__row0_col2 .pd-t::after {\n  content: "Max";\n}' in result
+    assert 'class="data row0 col2" >2<span class="pd-t"></span></td>' in result
+
+    # test Nan, empty string and bad column ignored
+    assert "#T_ #T__row1_col0:hover .pd-t {\n  visibility: visible;\n}" not in result
+    assert "#T_ #T__row1_col1:hover .pd-t {\n  visibility: visible;\n}" not in result
+    assert "#T_ #T__row0_col1:hover .pd-t {\n  visibility: visible;\n}" not in result
+    assert "#T_ #T__row1_col2:hover .pd-t {\n  visibility: visible;\n}" not in result
+    assert "Bad-Col" not in result
+
+
+def test_tooltip_ignored(styler):
+    # GH 21266
+    result = styler.to_html()  # no set_tooltips() creates no <span>
+    assert '<style type="text/css">\n</style>' in result
+    assert '<span class="pd-t"></span>' not in result
+
+
+def test_tooltip_css_class(styler):
+    # GH 21266
+    result = styler.set_tooltips(
+        DataFrame([["tooltip"]], index=["x"], columns=["A"]),
+        css_class="other-class",
+        props=[("color", "green")],
+    ).to_html()
+    assert "#T_ .other-class {\n  color: green;\n" in result
+    assert '#T_ #T__row0_col0 .other-class::after {\n  content: "tooltip";\n' in result
+
+    # GH 39563
+    result = styler.set_tooltips(  # set_tooltips overwrites previous
+        DataFrame([["tooltip"]], index=["x"], columns=["A"]),
+        css_class="another-class",
+        props="color:green;color:red;",
+    ).to_html()
+    assert "#T_ .another-class {\n  color: green;\n  color: red;\n}" in result

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/test_console.py

@@ -0,0 +1,72 @@
+import locale
+
+import pytest
+
+from pandas._config import detect_console_encoding
+
+
+class MockEncoding:
+    """
+    Used to add a side effect when accessing the 'encoding' property. If the
+    side effect is a str in nature, the value will be returned. Otherwise, the
+    side effect should be an exception that will be raised.
+    """
+
+    def __init__(self, encoding) -> None:
+        super().__init__()
+        self.val = encoding
+
+    @property
+    def encoding(self):
+        return self.raise_or_return(self.val)
+
+    @staticmethod
+    def raise_or_return(val):
+        if isinstance(val, str):
+            return val
+        else:
+            raise val
+
+
+@pytest.mark.parametrize("empty,filled", [["stdin", "stdout"], ["stdout", "stdin"]])
+def test_detect_console_encoding_from_stdout_stdin(monkeypatch, empty, filled):
+    # Ensures that when sys.stdout.encoding or sys.stdin.encoding is used when
+    # they have values filled.
+    # GH 21552
+    with monkeypatch.context() as context:
+        context.setattr(f"sys.{empty}", MockEncoding(""))
+        context.setattr(f"sys.{filled}", MockEncoding(filled))
+        assert detect_console_encoding() == filled
+
+
+@pytest.mark.parametrize("encoding", [AttributeError, OSError, "ascii"])
+def test_detect_console_encoding_fallback_to_locale(monkeypatch, encoding):
+    # GH 21552
+    with monkeypatch.context() as context:
+        context.setattr("locale.getpreferredencoding", lambda: "foo")
+        context.setattr("sys.stdout", MockEncoding(encoding))
+        assert detect_console_encoding() == "foo"
+
+
+@pytest.mark.parametrize(
+    "std,locale",
+    [
+        ["ascii", "ascii"],
+        ["ascii", locale.Error],
+        [AttributeError, "ascii"],
+        [AttributeError, locale.Error],
+        [OSError, "ascii"],
+        [OSError, locale.Error],
+    ],
+)
+def test_detect_console_encoding_fallback_to_default(monkeypatch, std, locale):
+    # When both the stdout/stdin encoding and locale preferred encoding checks
+    # fail (or return 'ascii', we should default to the sys default encoding.
+    # GH 21552
+    with monkeypatch.context() as context:
+        context.setattr(
+            "locale.getpreferredencoding", lambda: MockEncoding.raise_or_return(locale)
+        )
+        context.setattr("sys.stdout", MockEncoding(std))
+        context.setattr("sys.getdefaultencoding", lambda: "sysDefaultEncoding")
+        assert detect_console_encoding() == "sysDefaultEncoding"

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/test_eng_formatting.py

@@ -0,0 +1,254 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    reset_option,
+    set_eng_float_format,
+)
+
+from pandas.io.formats.format import EngFormatter
+
+
+@pytest.fixture(autouse=True)
+def reset_float_format():
+    yield
+    reset_option("display.float_format")
+
+
+class TestEngFormatter:
+    def test_eng_float_formatter2(self, float_frame):
+        df = float_frame
+        df.loc[5] = 0
+
+        set_eng_float_format()
+        repr(df)
+
+        set_eng_float_format(use_eng_prefix=True)
+        repr(df)
+
+        set_eng_float_format(accuracy=0)
+        repr(df)
+
+    def test_eng_float_formatter(self):
+        df = DataFrame({"A": [1.41, 141.0, 14100, 1410000.0]})
+
+        set_eng_float_format()
+        result = df.to_string()
+        expected = (
+            "             A\n"
+            "0    1.410E+00\n"
+            "1  141.000E+00\n"
+            "2   14.100E+03\n"
+            "3    1.410E+06"
+        )
+        assert result == expected
+
+        set_eng_float_format(use_eng_prefix=True)
+        result = df.to_string()
+        expected = "         A\n0    1.410\n1  141.000\n2  14.100k\n3   1.410M"
+        assert result == expected
+
+        set_eng_float_format(accuracy=0)
+        result = df.to_string()
+        expected = "         A\n0    1E+00\n1  141E+00\n2   14E+03\n3    1E+06"
+        assert result == expected
+
+    def compare(self, formatter, input, output):
+        formatted_input = formatter(input)
+        assert formatted_input == output
+
+    def compare_all(self, formatter, in_out):
+        """
+        Parameters:
+        -----------
+        formatter: EngFormatter under test
+        in_out: list of tuples. Each tuple = (number, expected_formatting)
+
+        It is tested if 'formatter(number) == expected_formatting'.
+        *number* should be >= 0 because formatter(-number) == fmt is also
+        tested. *fmt* is derived from *expected_formatting*
+        """
+        for input, output in in_out:
+            self.compare(formatter, input, output)
+            self.compare(formatter, -input, "-" + output[1:])
+
+    def test_exponents_with_eng_prefix(self):
+        formatter = EngFormatter(accuracy=3, use_eng_prefix=True)
+        f = np.sqrt(2)
+        in_out = [
+            (f * 10**-24, " 1.414y"),
+            (f * 10**-23, " 14.142y"),
+            (f * 10**-22, " 141.421y"),
+            (f * 10**-21, " 1.414z"),
+            (f * 10**-20, " 14.142z"),
+            (f * 10**-19, " 141.421z"),
+            (f * 10**-18, " 1.414a"),
+            (f * 10**-17, " 14.142a"),
+            (f * 10**-16, " 141.421a"),
+            (f * 10**-15, " 1.414f"),
+            (f * 10**-14, " 14.142f"),
+            (f * 10**-13, " 141.421f"),
+            (f * 10**-12, " 1.414p"),
+            (f * 10**-11, " 14.142p"),
+            (f * 10**-10, " 141.421p"),
+            (f * 10**-9, " 1.414n"),
+            (f * 10**-8, " 14.142n"),
+            (f * 10**-7, " 141.421n"),
+            (f * 10**-6, " 1.414u"),
+            (f * 10**-5, " 14.142u"),
+            (f * 10**-4, " 141.421u"),
+            (f * 10**-3, " 1.414m"),
+            (f * 10**-2, " 14.142m"),
+            (f * 10**-1, " 141.421m"),
+            (f * 10**0, " 1.414"),
+            (f * 10**1, " 14.142"),
+            (f * 10**2, " 141.421"),
+            (f * 10**3, " 1.414k"),
+            (f * 10**4, " 14.142k"),
+            (f * 10**5, " 141.421k"),
+            (f * 10**6, " 1.414M"),
+            (f * 10**7, " 14.142M"),
+            (f * 10**8, " 141.421M"),
+            (f * 10**9, " 1.414G"),
+            (f * 10**10, " 14.142G"),
+            (f * 10**11, " 141.421G"),
+            (f * 10**12, " 1.414T"),
+            (f * 10**13, " 14.142T"),
+            (f * 10**14, " 141.421T"),
+            (f * 10**15, " 1.414P"),
+            (f * 10**16, " 14.142P"),
+            (f * 10**17, " 141.421P"),
+            (f * 10**18, " 1.414E"),
+            (f * 10**19, " 14.142E"),
+            (f * 10**20, " 141.421E"),
+            (f * 10**21, " 1.414Z"),
+            (f * 10**22, " 14.142Z"),
+            (f * 10**23, " 141.421Z"),
+            (f * 10**24, " 1.414Y"),
+            (f * 10**25, " 14.142Y"),
+            (f * 10**26, " 141.421Y"),
+        ]
+        self.compare_all(formatter, in_out)
+
+    def test_exponents_without_eng_prefix(self):
+        formatter = EngFormatter(accuracy=4, use_eng_prefix=False)
+        f = np.pi
+        in_out = [
+            (f * 10**-24, " 3.1416E-24"),
+            (f * 10**-23, " 31.4159E-24"),
+            (f * 10**-22, " 314.1593E-24"),
+            (f * 10**-21, " 3.1416E-21"),
+            (f * 10**-20, " 31.4159E-21"),
+            (f * 10**-19, " 314.1593E-21"),
+            (f * 10**-18, " 3.1416E-18"),
+            (f * 10**-17, " 31.4159E-18"),
+            (f * 10**-16, " 314.1593E-18"),
+            (f * 10**-15, " 3.1416E-15"),
+            (f * 10**-14, " 31.4159E-15"),
+            (f * 10**-13, " 314.1593E-15"),
+            (f * 10**-12, " 3.1416E-12"),
+            (f * 10**-11, " 31.4159E-12"),
+            (f * 10**-10, " 314.1593E-12"),
+            (f * 10**-9, " 3.1416E-09"),
+            (f * 10**-8, " 31.4159E-09"),
+            (f * 10**-7, " 314.1593E-09"),
+            (f * 10**-6, " 3.1416E-06"),
+            (f * 10**-5, " 31.4159E-06"),
+            (f * 10**-4, " 314.1593E-06"),
+            (f * 10**-3, " 3.1416E-03"),
+            (f * 10**-2, " 31.4159E-03"),
+            (f * 10**-1, " 314.1593E-03"),
+            (f * 10**0, " 3.1416E+00"),
+            (f * 10**1, " 31.4159E+00"),
+            (f * 10**2, " 314.1593E+00"),
+            (f * 10**3, " 3.1416E+03"),
+            (f * 10**4, " 31.4159E+03"),
+            (f * 10**5, " 314.1593E+03"),
+            (f * 10**6, " 3.1416E+06"),
+            (f * 10**7, " 31.4159E+06"),
+            (f * 10**8, " 314.1593E+06"),
+            (f * 10**9, " 3.1416E+09"),
+            (f * 10**10, " 31.4159E+09"),
+            (f * 10**11, " 314.1593E+09"),
+            (f * 10**12, " 3.1416E+12"),
+            (f * 10**13, " 31.4159E+12"),
+            (f * 10**14, " 314.1593E+12"),
+            (f * 10**15, " 3.1416E+15"),
+            (f * 10**16, " 31.4159E+15"),
+            (f * 10**17, " 314.1593E+15"),
+            (f * 10**18, " 3.1416E+18"),
+            (f * 10**19, " 31.4159E+18"),
+            (f * 10**20, " 314.1593E+18"),
+            (f * 10**21, " 3.1416E+21"),
+            (f * 10**22, " 31.4159E+21"),
+            (f * 10**23, " 314.1593E+21"),
+            (f * 10**24, " 3.1416E+24"),
+            (f * 10**25, " 31.4159E+24"),
+            (f * 10**26, " 314.1593E+24"),
+        ]
+        self.compare_all(formatter, in_out)
+
+    def test_rounding(self):
+        formatter = EngFormatter(accuracy=3, use_eng_prefix=True)
+        in_out = [
+            (5.55555, " 5.556"),
+            (55.5555, " 55.556"),
+            (555.555, " 555.555"),
+            (5555.55, " 5.556k"),
+            (55555.5, " 55.556k"),
+            (555555, " 555.555k"),
+        ]
+        self.compare_all(formatter, in_out)
+
+        formatter = EngFormatter(accuracy=1, use_eng_prefix=True)
+        in_out = [
+            (5.55555, " 5.6"),
+            (55.5555, " 55.6"),
+            (555.555, " 555.6"),
+            (5555.55, " 5.6k"),
+            (55555.5, " 55.6k"),
+            (555555, " 555.6k"),
+        ]
+        self.compare_all(formatter, in_out)
+
+        formatter = EngFormatter(accuracy=0, use_eng_prefix=True)
+        in_out = [
+            (5.55555, " 6"),
+            (55.5555, " 56"),
+            (555.555, " 556"),
+            (5555.55, " 6k"),
+            (55555.5, " 56k"),
+            (555555, " 556k"),
+        ]
+        self.compare_all(formatter, in_out)
+
+        formatter = EngFormatter(accuracy=3, use_eng_prefix=True)
+        result = formatter(0)
+        assert result == " 0.000"
+
+    def test_nan(self):
+        # Issue #11981
+
+        formatter = EngFormatter(accuracy=1, use_eng_prefix=True)
+        result = formatter(np.nan)
+        assert result == "NaN"
+
+        df = DataFrame(
+            {
+                "a": [1.5, 10.3, 20.5],
+                "b": [50.3, 60.67, 70.12],
+                "c": [100.2, 101.33, 120.33],
+            }
+        )
+        pt = df.pivot_table(values="a", index="b", columns="c")
+        set_eng_float_format(accuracy=1)
+        result = pt.to_string()
+        assert "NaN" in result
+
+    def test_inf(self):
+        # Issue #11981
+
+        formatter = EngFormatter(accuracy=1, use_eng_prefix=True)
+        result = formatter(np.inf)
+        assert result == "inf"

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/test_format.py

@@ -0,0 +1,2293 @@
+"""
+Tests for the file pandas.io.formats.format, *not* tests for general formatting
+of pandas objects.
+"""
+from datetime import datetime
+from io import StringIO
+from pathlib import Path
+import re
+from shutil import get_terminal_size
+
+import numpy as np
+import pytest
+
+from pandas._config import using_pyarrow_string_dtype
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+    get_option,
+    option_context,
+    read_csv,
+    reset_option,
+)
+
+from pandas.io.formats import printing
+import pandas.io.formats.format as fmt
+
+
+@pytest.fixture(params=["string", "pathlike", "buffer"])
+def filepath_or_buffer_id(request):
+    """
+    A fixture yielding test ids for filepath_or_buffer testing.
+    """
+    return request.param
+
+
+@pytest.fixture
+def filepath_or_buffer(filepath_or_buffer_id, tmp_path):
+    """
+    A fixture yielding a string representing a filepath, a path-like object
+    and a StringIO buffer. Also checks that buffer is not closed.
+    """
+    if filepath_or_buffer_id == "buffer":
+        buf = StringIO()
+        yield buf
+        assert not buf.closed
+    else:
+        assert isinstance(tmp_path, Path)
+        if filepath_or_buffer_id == "pathlike":
+            yield tmp_path / "foo"
+        else:
+            yield str(tmp_path / "foo")
+
+
+@pytest.fixture
+def assert_filepath_or_buffer_equals(
+    filepath_or_buffer, filepath_or_buffer_id, encoding
+):
+    """
+    Assertion helper for checking filepath_or_buffer.
+    """
+    if encoding is None:
+        encoding = "utf-8"
+
+    def _assert_filepath_or_buffer_equals(expected):
+        if filepath_or_buffer_id == "string":
+            with open(filepath_or_buffer, encoding=encoding) as f:
+                result = f.read()
+        elif filepath_or_buffer_id == "pathlike":
+            result = filepath_or_buffer.read_text(encoding=encoding)
+        elif filepath_or_buffer_id == "buffer":
+            result = filepath_or_buffer.getvalue()
+        assert result == expected
+
+    return _assert_filepath_or_buffer_equals
+
+
+def has_info_repr(df):
+    r = repr(df)
+    c1 = r.split("\n")[0].startswith("<class")
+    c2 = r.split("\n")[0].startswith(r"&lt;class")  # _repr_html_
+    return c1 or c2
+
+
+def has_non_verbose_info_repr(df):
+    has_info = has_info_repr(df)
+    r = repr(df)
+
+    # 1. <class>
+    # 2. Index
+    # 3. Columns
+    # 4. dtype
+    # 5. memory usage
+    # 6. trailing newline
+    nv = len(r.split("\n")) == 6
+    return has_info and nv
+
+
+def has_horizontally_truncated_repr(df):
+    try:  # Check header row
+        fst_line = np.array(repr(df).splitlines()[0].split())
+        cand_col = np.where(fst_line == "...")[0][0]
+    except IndexError:
+        return False
+    # Make sure each row has this ... in the same place
+    r = repr(df)
+    for ix, _ in enumerate(r.splitlines()):
+        if not r.split()[cand_col] == "...":
+            return False
+    return True
+
+
+def has_vertically_truncated_repr(df):
+    r = repr(df)
+    only_dot_row = False
+    for row in r.splitlines():
+        if re.match(r"^[\.\ ]+$", row):
+            only_dot_row = True
+    return only_dot_row
+
+
+def has_truncated_repr(df):
+    return has_horizontally_truncated_repr(df) or has_vertically_truncated_repr(df)
+
+
+def has_doubly_truncated_repr(df):
+    return has_horizontally_truncated_repr(df) and has_vertically_truncated_repr(df)
+
+
+def has_expanded_repr(df):
+    r = repr(df)
+    for line in r.split("\n"):
+        if line.endswith("\\"):
+            return True
+    return False
+
+
+class TestDataFrameFormatting:
+    def test_repr_truncation(self):
+        max_len = 20
+        with option_context("display.max_colwidth", max_len):
+            df = DataFrame(
+                {
+                    "A": np.random.default_rng(2).standard_normal(10),
+                    "B": [
+                        "a"
+                        * np.random.default_rng(2).integers(max_len - 1, max_len + 1)
+                        for _ in range(10)
+                    ],
+                }
+            )
+            r = repr(df)
+            r = r[r.find("\n") + 1 :]
+
+            adj = printing.get_adjustment()
+
+            for line, value in zip(r.split("\n"), df["B"]):
+                if adj.len(value) + 1 > max_len:
+                    assert "..." in line
+                else:
+                    assert "..." not in line
+
+        with option_context("display.max_colwidth", 999999):
+            assert "..." not in repr(df)
+
+        with option_context("display.max_colwidth", max_len + 2):
+            assert "..." not in repr(df)
+
+    def test_repr_truncation_preserves_na(self):
+        # https://github.com/pandas-dev/pandas/issues/55630
+        df = DataFrame({"a": [pd.NA for _ in range(10)]})
+        with option_context("display.max_rows", 2, "display.show_dimensions", False):
+            assert repr(df) == "       a\n0   <NA>\n..   ...\n9   <NA>"
+
+    def test_max_colwidth_negative_int_raises(self):
+        # Deprecation enforced from:
+        # https://github.com/pandas-dev/pandas/issues/31532
+        with pytest.raises(
+            ValueError, match="Value must be a nonnegative integer or None"
+        ):
+            with option_context("display.max_colwidth", -1):
+                pass
+
+    def test_repr_chop_threshold(self):
+        df = DataFrame([[0.1, 0.5], [0.5, -0.1]])
+        reset_option("display.chop_threshold")  # default None
+        assert repr(df) == "     0    1\n0  0.1  0.5\n1  0.5 -0.1"
+
+        with option_context("display.chop_threshold", 0.2):
+            assert repr(df) == "     0    1\n0  0.0  0.5\n1  0.5  0.0"
+
+        with option_context("display.chop_threshold", 0.6):
+            assert repr(df) == "     0    1\n0  0.0  0.0\n1  0.0  0.0"
+
+        with option_context("display.chop_threshold", None):
+            assert repr(df) == "     0    1\n0  0.1  0.5\n1  0.5 -0.1"
+
+    def test_repr_chop_threshold_column_below(self):
+        # GH 6839: validation case
+
+        df = DataFrame([[10, 20, 30, 40], [8e-10, -1e-11, 2e-9, -2e-11]]).T
+
+        with option_context("display.chop_threshold", 0):
+            assert repr(df) == (
+                "      0             1\n"
+                "0  10.0  8.000000e-10\n"
+                "1  20.0 -1.000000e-11\n"
+                "2  30.0  2.000000e-09\n"
+                "3  40.0 -2.000000e-11"
+            )
+
+        with option_context("display.chop_threshold", 1e-8):
+            assert repr(df) == (
+                "      0             1\n"
+                "0  10.0  0.000000e+00\n"
+                "1  20.0  0.000000e+00\n"
+                "2  30.0  0.000000e+00\n"
+                "3  40.0  0.000000e+00"
+            )
+
+        with option_context("display.chop_threshold", 5e-11):
+            assert repr(df) == (
+                "      0             1\n"
+                "0  10.0  8.000000e-10\n"
+                "1  20.0  0.000000e+00\n"
+                "2  30.0  2.000000e-09\n"
+                "3  40.0  0.000000e+00"
+            )
+
+    def test_repr_no_backslash(self):
+        with option_context("mode.sim_interactive", True):
+            df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
+            assert "\\" not in repr(df)
+
+    def test_expand_frame_repr(self):
+        df_small = DataFrame("hello", index=[0], columns=[0])
+        df_wide = DataFrame("hello", index=[0], columns=range(10))
+        df_tall = DataFrame("hello", index=range(30), columns=range(5))
+
+        with option_context("mode.sim_interactive", True):
+            with option_context(
+                "display.max_columns",
+                10,
+                "display.width",
+                20,
+                "display.max_rows",
+                20,
+                "display.show_dimensions",
+                True,
+            ):
+                with option_context("display.expand_frame_repr", True):
+                    assert not has_truncated_repr(df_small)
+                    assert not has_expanded_repr(df_small)
+                    assert not has_truncated_repr(df_wide)
+                    assert has_expanded_repr(df_wide)
+                    assert has_vertically_truncated_repr(df_tall)
+                    assert has_expanded_repr(df_tall)
+
+                with option_context("display.expand_frame_repr", False):
+                    assert not has_truncated_repr(df_small)
+                    assert not has_expanded_repr(df_small)
+                    assert not has_horizontally_truncated_repr(df_wide)
+                    assert not has_expanded_repr(df_wide)
+                    assert has_vertically_truncated_repr(df_tall)
+                    assert not has_expanded_repr(df_tall)
+
+    def test_repr_non_interactive(self):
+        # in non interactive mode, there can be no dependency on the
+        # result of terminal auto size detection
+        df = DataFrame("hello", index=range(1000), columns=range(5))
+
+        with option_context(
+            "mode.sim_interactive", False, "display.width", 0, "display.max_rows", 5000
+        ):
+            assert not has_truncated_repr(df)
+            assert not has_expanded_repr(df)
+
+    def test_repr_truncates_terminal_size(self, monkeypatch):
+        # see gh-21180
+
+        terminal_size = (118, 96)
+        monkeypatch.setattr(
+            "pandas.io.formats.format.get_terminal_size", lambda: terminal_size
+        )
+
+        index = range(5)
+        columns = MultiIndex.from_tuples(
+            [
+                ("This is a long title with > 37 chars.", "cat"),
+                ("This is a loooooonger title with > 43 chars.", "dog"),
+            ]
+        )
+        df = DataFrame(1, index=index, columns=columns)
+
+        result = repr(df)
+
+        h1, h2 = result.split("\n")[:2]
+        assert "long" in h1
+        assert "loooooonger" in h1
+        assert "cat" in h2
+        assert "dog" in h2
+
+        # regular columns
+        df2 = DataFrame({"A" * 41: [1, 2], "B" * 41: [1, 2]})
+        result = repr(df2)
+
+        assert df2.columns[0] in result.split("\n")[0]
+
+    def test_repr_truncates_terminal_size_full(self, monkeypatch):
+        # GH 22984 ensure entire window is filled
+        terminal_size = (80, 24)
+        df = DataFrame(np.random.default_rng(2).random((1, 7)))
+
+        monkeypatch.setattr(
+            "pandas.io.formats.format.get_terminal_size", lambda: terminal_size
+        )
+        assert "..." not in str(df)
+
+    def test_repr_truncation_column_size(self):
+        # dataframe with last column very wide -> check it is not used to
+        # determine size of truncation (...) column
+        df = DataFrame(
+            {
+                "a": [108480, 30830],
+                "b": [12345, 12345],
+                "c": [12345, 12345],
+                "d": [12345, 12345],
+                "e": ["a" * 50] * 2,
+            }
+        )
+        assert "..." in str(df)
+        assert "    ...    " not in str(df)
+
+    def test_repr_max_columns_max_rows(self):
+        term_width, term_height = get_terminal_size()
+        if term_width < 10 or term_height < 10:
+            pytest.skip(f"terminal size too small, {term_width} x {term_height}")
+
+        def mkframe(n):
+            index = [f"{i:05d}" for i in range(n)]
+            return DataFrame(0, index, index)
+
+        df6 = mkframe(6)
+        df10 = mkframe(10)
+        with option_context("mode.sim_interactive", True):
+            with option_context("display.width", term_width * 2):
+                with option_context("display.max_rows", 5, "display.max_columns", 5):
+                    assert not has_expanded_repr(mkframe(4))
+                    assert not has_expanded_repr(mkframe(5))
+                    assert not has_expanded_repr(df6)
+                    assert has_doubly_truncated_repr(df6)
+
+                with option_context("display.max_rows", 20, "display.max_columns", 10):
+                    # Out off max_columns boundary, but no extending
+                    # since not exceeding width
+                    assert not has_expanded_repr(df6)
+                    assert not has_truncated_repr(df6)
+
+                with option_context("display.max_rows", 9, "display.max_columns", 10):
+                    # out vertical bounds can not result in expanded repr
+                    assert not has_expanded_repr(df10)
+                    assert has_vertically_truncated_repr(df10)
+
+            # width=None in terminal, auto detection
+            with option_context(
+                "display.max_columns",
+                100,
+                "display.max_rows",
+                term_width * 20,
+                "display.width",
+                None,
+            ):
+                df = mkframe((term_width // 7) - 2)
+                assert not has_expanded_repr(df)
+                df = mkframe((term_width // 7) + 2)
+                printing.pprint_thing(df._repr_fits_horizontal_())
+                assert has_expanded_repr(df)
+
+    def test_repr_min_rows(self):
+        df = DataFrame({"a": range(20)})
+
+        # default setting no truncation even if above min_rows
+        assert ".." not in repr(df)
+        assert ".." not in df._repr_html_()
+
+        df = DataFrame({"a": range(61)})
+
+        # default of max_rows 60 triggers truncation if above
+        assert ".." in repr(df)
+        assert ".." in df._repr_html_()
+
+        with option_context("display.max_rows", 10, "display.min_rows", 4):
+            # truncated after first two rows
+            assert ".." in repr(df)
+            assert "2  " not in repr(df)
+            assert "..." in df._repr_html_()
+            assert "<td>2</td>" not in df._repr_html_()
+
+        with option_context("display.max_rows", 12, "display.min_rows", None):
+            # when set to None, follow value of max_rows
+            assert "5    5" in repr(df)
+            assert "<td>5</td>" in df._repr_html_()
+
+        with option_context("display.max_rows", 10, "display.min_rows", 12):
+            # when set value higher as max_rows, use the minimum
+            assert "5    5" not in repr(df)
+            assert "<td>5</td>" not in df._repr_html_()
+
+        with option_context("display.max_rows", None, "display.min_rows", 12):
+            # max_rows of None -> never truncate
+            assert ".." not in repr(df)
+            assert ".." not in df._repr_html_()
+
+    def test_str_max_colwidth(self):
+        # GH 7856
+        df = DataFrame(
+            [
+                {
+                    "a": "foo",
+                    "b": "bar",
+                    "c": "uncomfortably long line with lots of stuff",
+                    "d": 1,
+                },
+                {"a": "foo", "b": "bar", "c": "stuff", "d": 1},
+            ]
+        )
+        df.set_index(["a", "b", "c"])
+        assert str(df) == (
+            "     a    b                                           c  d\n"
+            "0  foo  bar  uncomfortably long line with lots of stuff  1\n"
+            "1  foo  bar                                       stuff  1"
+        )
+        with option_context("max_colwidth", 20):
+            assert str(df) == (
+                "     a    b                    c  d\n"
+                "0  foo  bar  uncomfortably lo...  1\n"
+                "1  foo  bar                stuff  1"
+            )
+
+    def test_auto_detect(self):
+        term_width, term_height = get_terminal_size()
+        fac = 1.05  # Arbitrary large factor to exceed term width
+        cols = range(int(term_width * fac))
+        index = range(10)
+        df = DataFrame(index=index, columns=cols)
+        with option_context("mode.sim_interactive", True):
+            with option_context("display.max_rows", None):
+                with option_context("display.max_columns", None):
+                    # Wrap around with None
+                    assert has_expanded_repr(df)
+            with option_context("display.max_rows", 0):
+                with option_context("display.max_columns", 0):
+                    # Truncate with auto detection.
+                    assert has_horizontally_truncated_repr(df)
+
+            index = range(int(term_height * fac))
+            df = DataFrame(index=index, columns=cols)
+            with option_context("display.max_rows", 0):
+                with option_context("display.max_columns", None):
+                    # Wrap around with None
+                    assert has_expanded_repr(df)
+                    # Truncate vertically
+                    assert has_vertically_truncated_repr(df)
+
+            with option_context("display.max_rows", None):
+                with option_context("display.max_columns", 0):
+                    assert has_horizontally_truncated_repr(df)
+
+    def test_to_string_repr_unicode2(self):
+        idx = Index(["abc", "\u03c3a", "aegdvg"])
+        ser = Series(np.random.default_rng(2).standard_normal(len(idx)), idx)
+        rs = repr(ser).split("\n")
+        line_len = len(rs[0])
+        for line in rs[1:]:
+            try:
+                line = line.decode(get_option("display.encoding"))
+            except AttributeError:
+                pass
+            if not line.startswith("dtype:"):
+                assert len(line) == line_len
+
+    def test_east_asian_unicode_false(self):
+        # not aligned properly because of east asian width
+
+        # mid col
+        df = DataFrame(
+            {"a": ["あ", "いいい", "う", "ええええええ"], "b": [1, 222, 33333, 4]},
+            index=["a", "bb", "c", "ddd"],
+        )
+        expected = (
+            "          a      b\na         あ      1\n"
+            "bb      いいい    222\nc         う  33333\n"
+            "ddd  ええええええ      4"
+        )
+        assert repr(df) == expected
+
+        # last col
+        df = DataFrame(
+            {"a": [1, 222, 33333, 4], "b": ["あ", "いいい", "う", "ええええええ"]},
+            index=["a", "bb", "c", "ddd"],
+        )
+        expected = (
+            "         a       b\na        1       あ\n"
+            "bb     222     いいい\nc    33333       う\n"
+            "ddd      4  ええええええ"
+        )
+        assert repr(df) == expected
+
+        # all col
+        df = DataFrame(
+            {
+                "a": ["あああああ", "い", "う", "えええ"],
+                "b": ["あ", "いいい", "う", "ええええええ"],
+            },
+            index=["a", "bb", "c", "ddd"],
+        )
+        expected = (
+            "         a       b\na    あああああ       あ\n"
+            "bb       い     いいい\nc        う       う\n"
+            "ddd    えええ  ええええええ"
+        )
+        assert repr(df) == expected
+
+        # column name
+        df = DataFrame(
+            {
+                "b": ["あ", "いいい", "う", "ええええええ"],
+                "あああああ": [1, 222, 33333, 4],
+            },
+            index=["a", "bb", "c", "ddd"],
+        )
+        expected = (
+            "          b  あああああ\na         あ      1\n"
+            "bb      いいい    222\nc         う  33333\n"
+            "ddd  ええええええ      4"
+        )
+        assert repr(df) == expected
+
+        # index
+        df = DataFrame(
+            {
+                "a": ["あああああ", "い", "う", "えええ"],
+                "b": ["あ", "いいい", "う", "ええええええ"],
+            },
+            index=["あああ", "いいいいいい", "うう", "え"],
+        )
+        expected = (
+            "            a       b\nあああ     あああああ       あ\n"
+            "いいいいいい      い     いいい\nうう          う       う\n"
+            "え         えええ  ええええええ"
+        )
+        assert repr(df) == expected
+
+        # index name
+        df = DataFrame(
+            {
+                "a": ["あああああ", "い", "う", "えええ"],
+                "b": ["あ", "いいい", "う", "ええええええ"],
+            },
+            index=Index(["あ", "い", "うう", "え"], name="おおおお"),
+        )
+        expected = (
+            "          a       b\n"
+            "おおおお               \n"
+            "あ     あああああ       あ\n"
+            "い         い     いいい\n"
+            "うう        う       う\n"
+            "え       えええ  ええええええ"
+        )
+        assert repr(df) == expected
+
+        # all
+        df = DataFrame(
+            {
+                "あああ": ["あああ", "い", "う", "えええええ"],
+                "いいいいい": ["あ", "いいい", "う", "ええ"],
+            },
+            index=Index(["あ", "いいい", "うう", "え"], name="お"),
+        )
+        expected = (
+            "       あああ いいいいい\n"
+            "お               \n"
+            "あ      あああ     あ\n"
+            "いいい      い   いいい\n"
+            "うう       う     う\n"
+            "え    えええええ    ええ"
+        )
+        assert repr(df) == expected
+
+        # MultiIndex
+        idx = MultiIndex.from_tuples(
+            [("あ", "いい"), ("う", "え"), ("おおお", "かかかか"), ("き", "くく")]
+        )
+        df = DataFrame(
+            {
+                "a": ["あああああ", "い", "う", "えええ"],
+                "b": ["あ", "いいい", "う", "ええええええ"],
+            },
+            index=idx,
+        )
+        expected = (
+            "              a       b\n"
+            "あ   いい    あああああ       あ\n"
+            "う   え         い     いいい\n"
+            "おおお かかかか      う       う\n"
+            "き   くく      えええ  ええええええ"
+        )
+        assert repr(df) == expected
+
+        # truncate
+        with option_context("display.max_rows", 3, "display.max_columns", 3):
+            df = DataFrame(
+                {
+                    "a": ["あああああ", "い", "う", "えええ"],
+                    "b": ["あ", "いいい", "う", "ええええええ"],
+                    "c": ["お", "か", "ききき", "くくくくくく"],
+                    "ああああ": ["さ", "し", "す", "せ"],
+                },
+                columns=["a", "b", "c", "ああああ"],
+            )
+
+            expected = (
+                "        a  ... ああああ\n0   あああああ  ...    さ\n"
+                "..    ...  ...  ...\n3     えええ  ...    せ\n"
+                "\n[4 rows x 4 columns]"
+            )
+            assert repr(df) == expected
+
+            df.index = ["あああ", "いいいい", "う", "aaa"]
+            expected = (
+                "         a  ... ああああ\nあああ  あああああ  ...    さ\n"
+                "..     ...  ...  ...\naaa    えええ  ...    せ\n"
+                "\n[4 rows x 4 columns]"
+            )
+            assert repr(df) == expected
+
+    def test_east_asian_unicode_true(self):
+        # Enable Unicode option -----------------------------------------
+        with option_context("display.unicode.east_asian_width", True):
+            # mid col
+            df = DataFrame(
+                {"a": ["あ", "いいい", "う", "ええええええ"], "b": [1, 222, 33333, 4]},
+                index=["a", "bb", "c", "ddd"],
+            )
+            expected = (
+                "                a      b\na              あ      1\n"
+                "bb         いいい    222\nc              う  33333\n"
+                "ddd  ええええええ      4"
+            )
+            assert repr(df) == expected
+
+            # last col
+            df = DataFrame(
+                {"a": [1, 222, 33333, 4], "b": ["あ", "いいい", "う", "ええええええ"]},
+                index=["a", "bb", "c", "ddd"],
+            )
+            expected = (
+                "         a             b\na        1            あ\n"
+                "bb     222        いいい\nc    33333            う\n"
+                "ddd      4  ええええええ"
+            )
+            assert repr(df) == expected
+
+            # all col
+            df = DataFrame(
+                {
+                    "a": ["あああああ", "い", "う", "えええ"],
+                    "b": ["あ", "いいい", "う", "ええええええ"],
+                },
+                index=["a", "bb", "c", "ddd"],
+            )
+            expected = (
+                "              a             b\n"
+                "a    あああああ            あ\n"
+                "bb           い        いいい\n"
+                "c            う            う\n"
+                "ddd      えええ  ええええええ"
+            )
+            assert repr(df) == expected
+
+            # column name
+            df = DataFrame(
+                {
+                    "b": ["あ", "いいい", "う", "ええええええ"],
+                    "あああああ": [1, 222, 33333, 4],
+                },
+                index=["a", "bb", "c", "ddd"],
+            )
+            expected = (
+                "                b  あああああ\n"
+                "a              あ           1\n"
+                "bb         いいい         222\n"
+                "c              う       33333\n"
+                "ddd  ええええええ           4"
+            )
+            assert repr(df) == expected
+
+            # index
+            df = DataFrame(
+                {
+                    "a": ["あああああ", "い", "う", "えええ"],
+                    "b": ["あ", "いいい", "う", "ええええええ"],
+                },
+                index=["あああ", "いいいいいい", "うう", "え"],
+            )
+            expected = (
+                "                       a             b\n"
+                "あああ        あああああ            あ\n"
+                "いいいいいい          い        いいい\n"
+                "うう                  う            う\n"
+                "え                えええ  ええええええ"
+            )
+            assert repr(df) == expected
+
+            # index name
+            df = DataFrame(
+                {
+                    "a": ["あああああ", "い", "う", "えええ"],
+                    "b": ["あ", "いいい", "う", "ええええええ"],
+                },
+                index=Index(["あ", "い", "うう", "え"], name="おおおお"),
+            )
+            expected = (
+                "                   a             b\n"
+                "おおおお                          \n"
+                "あ        あああああ            あ\n"
+                "い                い        いいい\n"
+                "うう              う            う\n"
+                "え            えええ  ええええええ"
+            )
+            assert repr(df) == expected
+
+            # all
+            df = DataFrame(
+                {
+                    "あああ": ["あああ", "い", "う", "えええええ"],
+                    "いいいいい": ["あ", "いいい", "う", "ええ"],
+                },
+                index=Index(["あ", "いいい", "うう", "え"], name="お"),
+            )
+            expected = (
+                "            あああ いいいいい\n"
+                "お                           \n"
+                "あ          あああ         あ\n"
+                "いいい          い     いいい\n"
+                "うう            う         う\n"
+                "え      えええええ       ええ"
+            )
+            assert repr(df) == expected
+
+            # MultiIndex
+            idx = MultiIndex.from_tuples(
+                [("あ", "いい"), ("う", "え"), ("おおお", "かかかか"), ("き", "くく")]
+            )
+            df = DataFrame(
+                {
+                    "a": ["あああああ", "い", "う", "えええ"],
+                    "b": ["あ", "いいい", "う", "ええええええ"],
+                },
+                index=idx,
+            )
+            expected = (
+                "                          a             b\n"
+                "あ     いい      あああああ            あ\n"
+                "う     え                い        いいい\n"
+                "おおお かかかか          う            う\n"
+                "き     くく          えええ  ええええええ"
+            )
+            assert repr(df) == expected
+
+            # truncate
+            with option_context("display.max_rows", 3, "display.max_columns", 3):
+                df = DataFrame(
+                    {
+                        "a": ["あああああ", "い", "う", "えええ"],
+                        "b": ["あ", "いいい", "う", "ええええええ"],
+                        "c": ["お", "か", "ききき", "くくくくくく"],
+                        "ああああ": ["さ", "し", "す", "せ"],
+                    },
+                    columns=["a", "b", "c", "ああああ"],
+                )
+
+                expected = (
+                    "             a  ... ああああ\n"
+                    "0   あああああ  ...       さ\n"
+                    "..         ...  ...      ...\n"
+                    "3       えええ  ...       せ\n"
+                    "\n[4 rows x 4 columns]"
+                )
+                assert repr(df) == expected
+
+                df.index = ["あああ", "いいいい", "う", "aaa"]
+                expected = (
+                    "                 a  ... ああああ\n"
+                    "あああ  あああああ  ...       さ\n"
+                    "...            ...  ...      ...\n"
+                    "aaa         えええ  ...       せ\n"
+                    "\n[4 rows x 4 columns]"
+                )
+                assert repr(df) == expected
+
+            # ambiguous unicode
+            df = DataFrame(
+                {
+                    "b": ["あ", "いいい", "¡¡", "ええええ��え"],
+                    "あああああ": [1, 222, 33333, 4],
+                },
+                index=["a", "bb", "c", "¡¡¡"],
+            )
+            expected = (
+                "                b  あああああ\n"
+                "a              あ           1\n"
+                "bb         いいい         222\n"
+                "c              ¡¡       33333\n"
+                "¡¡¡  ええええええ           4"
+            )
+            assert repr(df) == expected
+
+    def test_to_string_buffer_all_unicode(self):
+        buf = StringIO()
+
+        empty = DataFrame({"c/\u03c3": Series(dtype=object)})
+        nonempty = DataFrame({"c/\u03c3": Series([1, 2, 3])})
+
+        print(empty, file=buf)
+        print(nonempty, file=buf)
+
+        # this should work
+        buf.getvalue()
+
+    @pytest.mark.parametrize(
+        "index_scalar",
+        [
+            "a" * 10,
+            1,
+            Timestamp(2020, 1, 1),
+            pd.Period("2020-01-01"),
+        ],
+    )
+    @pytest.mark.parametrize("h", [10, 20])
+    @pytest.mark.parametrize("w", [10, 20])
+    def test_to_string_truncate_indices(self, index_scalar, h, w):
+        with option_context("display.expand_frame_repr", False):
+            df = DataFrame(
+                index=[index_scalar] * h, columns=[str(i) * 10 for i in range(w)]
+            )
+            with option_context("display.max_rows", 15):
+                if h == 20:
+                    assert has_vertically_truncated_repr(df)
+                else:
+                    assert not has_vertically_truncated_repr(df)
+            with option_context("display.max_columns", 15):
+                if w == 20:
+                    assert has_horizontally_truncated_repr(df)
+                else:
+                    assert not has_horizontally_truncated_repr(df)
+            with option_context("display.max_rows", 15, "display.max_columns", 15):
+                if h == 20 and w == 20:
+                    assert has_doubly_truncated_repr(df)
+                else:
+                    assert not has_doubly_truncated_repr(df)
+
+    def test_to_string_truncate_multilevel(self):
+        arrays = [
+            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+            ["one", "two", "one", "two", "one", "two", "one", "two"],
+        ]
+        df = DataFrame(index=arrays, columns=arrays)
+        with option_context("display.max_rows", 7, "display.max_columns", 7):
+            assert has_doubly_truncated_repr(df)
+
+    @pytest.mark.parametrize("dtype", ["object", "datetime64[us]"])
+    def test_truncate_with_different_dtypes(self, dtype):
+        # 11594, 12045
+        # when truncated the dtypes of the splits can differ
+
+        # 11594
+        ser = Series(
+            [datetime(2012, 1, 1)] * 10
+            + [datetime(1012, 1, 2)]
+            + [datetime(2012, 1, 3)] * 10,
+            dtype=dtype,
+        )
+
+        with option_context("display.max_rows", 8):
+            result = str(ser)
+        assert dtype in result
+
+    def test_truncate_with_different_dtypes2(self):
+        # 12045
+        df = DataFrame({"text": ["some words"] + [None] * 9}, dtype=object)
+
+        with option_context("display.max_rows", 8, "display.max_columns", 3):
+            result = str(df)
+            assert "None" in result
+            assert "NaN" not in result
+
+    def test_truncate_with_different_dtypes_multiindex(self):
+        # GH#13000
+        df = DataFrame({"Vals": range(100)})
+        frame = pd.concat([df], keys=["Sweep"], names=["Sweep", "Index"])
+        result = repr(frame)
+
+        result2 = repr(frame.iloc[:5])
+        assert result.startswith(result2)
+
+    def test_datetimelike_frame(self):
+        # GH 12211
+        df = DataFrame({"date": [Timestamp("20130101").tz_localize("UTC")] + [NaT] * 5})
+
+        with option_context("display.max_rows", 5):
+            result = str(df)
+            assert "2013-01-01 00:00:00+00:00" in result
+            assert "NaT" in result
+            assert "..." in result
+            assert "[6 rows x 1 columns]" in result
+
+        dts = [Timestamp("2011-01-01", tz="US/Eastern")] * 5 + [NaT] * 5
+        df = DataFrame({"dt": dts, "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]})
+        with option_context("display.max_rows", 5):
+            expected = (
+                "                          dt   x\n"
+                "0  2011-01-01 00:00:00-05:00   1\n"
+                "1  2011-01-01 00:00:00-05:00   2\n"
+                "..                       ...  ..\n"
+                "8                        NaT   9\n"
+                "9                        NaT  10\n\n"
+                "[10 rows x 2 columns]"
+            )
+            assert repr(df) == expected
+
+        dts = [NaT] * 5 + [Timestamp("2011-01-01", tz="US/Eastern")] * 5
+        df = DataFrame({"dt": dts, "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]})
+        with option_context("display.max_rows", 5):
+            expected = (
+                "                          dt   x\n"
+                "0                        NaT   1\n"
+                "1                        NaT   2\n"
+                "..                       ...  ..\n"
+                "8  2011-01-01 00:00:00-05:00   9\n"
+                "9  2011-01-01 00:00:00-05:00  10\n\n"
+                "[10 rows x 2 columns]"
+            )
+            assert repr(df) == expected
+
+        dts = [Timestamp("2011-01-01", tz="Asia/Tokyo")] * 5 + [
+            Timestamp("2011-01-01", tz="US/Eastern")
+        ] * 5
+        df = DataFrame({"dt": dts, "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]})
+        with option_context("display.max_rows", 5):
+            expected = (
+                "                           dt   x\n"
+                "0   2011-01-01 00:00:00+09:00   1\n"
+                "1   2011-01-01 00:00:00+09:00   2\n"
+                "..                        ...  ..\n"
+                "8   2011-01-01 00:00:00-05:00   9\n"
+                "9   2011-01-01 00:00:00-05:00  10\n\n"
+                "[10 rows x 2 columns]"
+            )
+            assert repr(df) == expected
+
+    @pytest.mark.parametrize(
+        "start_date",
+        [
+            "2017-01-01 23:59:59.999999999",
+            "2017-01-01 23:59:59.99999999",
+            "2017-01-01 23:59:59.9999999",
+            "2017-01-01 23:59:59.999999",
+            "2017-01-01 23:59:59.99999",
+            "2017-01-01 23:59:59.9999",
+        ],
+    )
+    def test_datetimeindex_highprecision(self, start_date):
+        # GH19030
+        # Check that high-precision time values for the end of day are
+        # included in repr for DatetimeIndex
+        df = DataFrame({"A": date_range(start=start_date, freq="D", periods=5)})
+        result = str(df)
+        assert start_date in result
+
+        dti = date_range(start=start_date, freq="D", periods=5)
+        df = DataFrame({"A": range(5)}, index=dti)
+        result = str(df.index)
+        assert start_date in result
+
+    def test_string_repr_encoding(self, datapath):
+        filepath = datapath("io", "parser", "data", "unicode_series.csv")
+        df = read_csv(filepath, header=None, encoding="latin1")
+        repr(df)
+        repr(df[1])
+
+    def test_repr_corner(self):
+        # representing infs poses no problems
+        df = DataFrame({"foo": [-np.inf, np.inf]})
+        repr(df)
+
+    def test_frame_info_encoding(self):
+        index = ["'Til There Was You (1997)", "ldum klaka (Cold Fever) (1994)"]
+        with option_context("display.max_rows", 1):
+            df = DataFrame(columns=["a", "b", "c"], index=index)
+            repr(df)
+            repr(df.T)
+
+    def test_wide_repr(self):
+        with option_context(
+            "mode.sim_interactive",
+            True,
+            "display.show_dimensions",
+            True,
+            "display.max_columns",
+            20,
+        ):
+            max_cols = get_option("display.max_columns")
+            df = DataFrame([["a" * 25] * (max_cols - 1)] * 10)
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
+
+            assert f"10 rows x {max_cols - 1} columns" in rep_str
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
+            assert rep_str != wide_repr
+
+            with option_context("display.width", 120):
+                wider_repr = repr(df)
+                assert len(wider_repr) < len(wide_repr)
+
+    def test_wide_repr_wide_columns(self):
+        with option_context("mode.sim_interactive", True, "display.max_columns", 20):
+            df = DataFrame(
+                np.random.default_rng(2).standard_normal((5, 3)),
+                columns=["a" * 90, "b" * 90, "c" * 90],
+            )
+            rep_str = repr(df)
+
+            assert len(rep_str.splitlines()) == 20
+
+    def test_wide_repr_named(self):
+        with option_context("mode.sim_interactive", True, "display.max_columns", 20):
+            max_cols = get_option("display.max_columns")
+            df = DataFrame([["a" * 25] * (max_cols - 1)] * 10)
+            df.index.name = "DataFrame Index"
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
+            assert rep_str != wide_repr
+
+            with option_context("display.width", 150):
+                wider_repr = repr(df)
+                assert len(wider_repr) < len(wide_repr)
+
+            for line in wide_repr.splitlines()[1::13]:
+                assert "DataFrame Index" in line
+
+    def test_wide_repr_multiindex(self):
+        with option_context("mode.sim_interactive", True, "display.max_columns", 20):
+            midx = MultiIndex.from_arrays([["a" * 5] * 10] * 2)
+            max_cols = get_option("display.max_columns")
+            df = DataFrame([["a" * 25] * (max_cols - 1)] * 10, index=midx)
+            df.index.names = ["Level 0", "Level 1"]
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
+            assert rep_str != wide_repr
+
+            with option_context("display.width", 150):
+                wider_repr = repr(df)
+                assert len(wider_repr) < len(wide_repr)
+
+            for line in wide_repr.splitlines()[1::13]:
+                assert "Level 0 Level 1" in line
+
+    def test_wide_repr_multiindex_cols(self):
+        with option_context("mode.sim_interactive", True, "display.max_columns", 20):
+            max_cols = get_option("display.max_columns")
+            midx = MultiIndex.from_arrays([["a" * 5] * 10] * 2)
+            mcols = MultiIndex.from_arrays([["b" * 3] * (max_cols - 1)] * 2)
+            df = DataFrame(
+                [["c" * 25] * (max_cols - 1)] * 10, index=midx, columns=mcols
+            )
+            df.index.names = ["Level 0", "Level 1"]
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
+            assert rep_str != wide_repr
+
+        with option_context("display.width", 150, "display.max_columns", 20):
+            wider_repr = repr(df)
+            assert len(wider_repr) < len(wide_repr)
+
+    def test_wide_repr_unicode(self):
+        with option_context("mode.sim_interactive", True, "display.max_columns", 20):
+            max_cols = 20
+            df = DataFrame([["a" * 25] * 10] * (max_cols - 1))
+            with option_context("display.expand_frame_repr", False):
+                rep_str = repr(df)
+            with option_context("display.expand_frame_repr", True):
+                wide_repr = repr(df)
+            assert rep_str != wide_repr
+
+            with option_context("display.width", 150):
+                wider_repr = repr(df)
+                assert len(wider_repr) < len(wide_repr)
+
+    def test_wide_repr_wide_long_columns(self):
+        with option_context("mode.sim_interactive", True):
+            df = DataFrame({"a": ["a" * 30, "b" * 30], "b": ["c" * 70, "d" * 80]})
+
+            result = repr(df)
+            assert "ccccc" in result
+            assert "ddddd" in result
+
+    def test_long_series(self):
+        n = 1000
+        s = Series(
+            np.random.default_rng(2).integers(-50, 50, n),
+            index=[f"s{x:04d}" for x in range(n)],
+            dtype="int64",
+        )
+
+        str_rep = str(s)
+        nmatches = len(re.findall("dtype", str_rep))
+        assert nmatches == 1
+
+    def test_to_string_ascii_error(self):
+        data = [
+            (
+                "0  ",
+                "                        .gitignore ",
+                "     5 ",
+                " \xe2\x80\xa2\xe2\x80\xa2\xe2\x80\xa2\xe2\x80\xa2\xe2\x80\xa2",
+            )
+        ]
+        df = DataFrame(data)
+
+        # it works!
+        repr(df)
+
+    def test_show_dimensions(self):
+        df = DataFrame(123, index=range(10, 15), columns=range(30))
+
+        with option_context(
+            "display.max_rows",
+            10,
+            "display.max_columns",
+            40,
+            "display.width",
+            500,
+            "display.expand_frame_repr",
+            "info",
+            "display.show_dimensions",
+            True,
+        ):
+            assert "5 rows" in str(df)
+            assert "5 rows" in df._repr_html_()
+        with option_context(
+            "display.max_rows",
+            10,
+            "display.max_columns",
+            40,
+            "display.width",
+            500,
+            "display.expand_frame_repr",
+            "info",
+            "display.show_dimensions",
+            False,
+        ):
+            assert "5 rows" not in str(df)
+            assert "5 rows" not in df._repr_html_()
+        with option_context(
+            "display.max_rows",
+            2,
+            "display.max_columns",
+            2,
+            "display.width",
+            500,
+            "display.expand_frame_repr",
+            "info",
+            "display.show_dimensions",
+            "truncate",
+        ):
+            assert "5 rows" in str(df)
+            assert "5 rows" in df._repr_html_()
+        with option_context(
+            "display.max_rows",
+            10,
+            "display.max_columns",
+            40,
+            "display.width",
+            500,
+            "display.expand_frame_repr",
+            "info",
+            "display.show_dimensions",
+            "truncate",
+        ):
+            assert "5 rows" not in str(df)
+            assert "5 rows" not in df._repr_html_()
+
+    def test_info_repr(self):
+        # GH#21746 For tests inside a terminal (i.e. not CI) we need to detect
+        # the terminal size to ensure that we try to print something "too big"
+        term_width, term_height = get_terminal_size()
+
+        max_rows = 60
+        max_cols = 20 + (max(term_width, 80) - 80) // 4
+        # Long
+        h, w = max_rows + 1, max_cols - 1
+        df = DataFrame({k: np.arange(1, 1 + h) for k in np.arange(w)})
+        assert has_vertically_truncated_repr(df)
+        with option_context("display.large_repr", "info"):
+            assert has_info_repr(df)
+
+        # Wide
+        h, w = max_rows - 1, max_cols + 1
+        df = DataFrame({k: np.arange(1, 1 + h) for k in np.arange(w)})
+        assert has_horizontally_truncated_repr(df)
+        with option_context(
+            "display.large_repr", "info", "display.max_columns", max_cols
+        ):
+            assert has_info_repr(df)
+
+    def test_info_repr_max_cols(self):
+        # GH #6939
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 5)))
+        with option_context(
+            "display.large_repr",
+            "info",
+            "display.max_columns",
+            1,
+            "display.max_info_columns",
+            4,
+        ):
+            assert has_non_verbose_info_repr(df)
+
+        with option_context(
+            "display.large_repr",
+            "info",
+            "display.max_columns",
+            1,
+            "display.max_info_columns",
+            5,
+        ):
+            assert not has_non_verbose_info_repr(df)
+
+        # FIXME: don't leave commented-out
+        # test verbose overrides
+        # set_option('display.max_info_columns', 4)  # exceeded
+
+    def test_pprint_pathological_object(self):
+        """
+        If the test fails, it at least won't hang.
+        """
+
+        class A:
+            def __getitem__(self, key):
+                return 3  # obviously simplified
+
+        df = DataFrame([A()])
+        repr(df)  # just don't die
+
+    def test_float_trim_zeros(self):
+        vals = [
+            2.08430917305e10,
+            3.52205017305e10,
+            2.30674817305e10,
+            2.03954217305e10,
+            5.59897817305e10,
+        ]
+        skip = True
+        for line in repr(DataFrame({"A": vals})).split("\n")[:-2]:
+            if line.startswith("dtype:"):
+                continue
+            if _three_digit_exp():
+                assert ("+010" in line) or skip
+            else:
+                assert ("+10" in line) or skip
+            skip = False
+
+    @pytest.mark.parametrize(
+        "data, expected",
+        [
+            (["3.50"], "0    3.50\ndtype: object"),
+            ([1.20, "1.00"], "0     1.2\n1    1.00\ndtype: object"),
+            ([np.nan], "0   NaN\ndtype: float64"),
+            ([None], "0    None\ndtype: object"),
+            (["3.50", np.nan], "0    3.50\n1     NaN\ndtype: object"),
+            ([3.50, np.nan], "0    3.5\n1    NaN\ndtype: float64"),
+            ([3.50, np.nan, "3.50"], "0     3.5\n1     NaN\n2    3.50\ndtype: object"),
+            ([3.50, None, "3.50"], "0     3.5\n1    None\n2    3.50\ndtype: object"),
+        ],
+    )
+    def test_repr_str_float_truncation(self, data, expected, using_infer_string):
+        # GH#38708
+        series = Series(data, dtype=object if "3.50" in data else None)
+        result = repr(series)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "float_format,expected",
+        [
+            ("{:,.0f}".format, "0   1,000\n1    test\ndtype: object"),
+            ("{:.4f}".format, "0   1000.0000\n1        test\ndtype: object"),
+        ],
+    )
+    def test_repr_float_format_in_object_col(self, float_format, expected):
+        # GH#40024
+        df = Series([1000.0, "test"])
+        with option_context("display.float_format", float_format):
+            result = repr(df)
+
+        assert result == expected
+
+    def test_period(self):
+        # GH 12615
+        df = DataFrame(
+            {
+                "A": pd.period_range("2013-01", periods=4, freq="M"),
+                "B": [
+                    pd.Period("2011-01", freq="M"),
+                    pd.Period("2011-02-01", freq="D"),
+                    pd.Period("2011-03-01 09:00", freq="h"),
+                    pd.Period("2011-04", freq="M"),
+                ],
+                "C": list("abcd"),
+            }
+        )
+        exp = (
+            "         A                 B  C\n"
+            "0  2013-01           2011-01  a\n"
+            "1  2013-02        2011-02-01  b\n"
+            "2  2013-03  2011-03-01 09:00  c\n"
+            "3  2013-04           2011-04  d"
+        )
+        assert str(df) == exp
+
+    @pytest.mark.parametrize(
+        "length, max_rows, min_rows, expected",
+        [
+            (10, 10, 10, 10),
+            (10, 10, None, 10),
+            (10, 8, None, 8),
+            (20, 30, 10, 30),  # max_rows > len(frame), hence max_rows
+            (50, 30, 10, 10),  # max_rows < len(frame), hence min_rows
+            (100, 60, 10, 10),  # same
+            (60, 60, 10, 60),  # edge case
+            (61, 60, 10, 10),  # edge case
+        ],
+    )
+    def test_max_rows_fitted(self, length, min_rows, max_rows, expected):
+        """Check that display logic is correct.
+
+        GH #37359
+
+        See description here:
+        https://pandas.pydata.org/docs/dev/user_guide/options.html#frequently-used-options
+        """
+        formatter = fmt.DataFrameFormatter(
+            DataFrame(np.random.default_rng(2).random((length, 3))),
+            max_rows=max_rows,
+            min_rows=min_rows,
+        )
+        result = formatter.max_rows_fitted
+        assert result == expected
+
+
+def gen_series_formatting():
+    s1 = Series(["a"] * 100)
+    s2 = Series(["ab"] * 100)
+    s3 = Series(["a", "ab", "abc", "abcd", "abcde", "abcdef"])
+    s4 = s3[::-1]
+    test_sers = {"onel": s1, "twol": s2, "asc": s3, "desc": s4}
+    return test_sers
+
+
+class TestSeriesFormatting:
+    def test_freq_name_separation(self):
+        s = Series(
+            np.random.default_rng(2).standard_normal(10),
+            index=date_range("1/1/2000", periods=10),
+            name=0,
+        )
+
+        result = repr(s)
+        assert "Freq: D, Name: 0" in result
+
+    def test_unicode_name_in_footer(self):
+        s = Series([1, 2], name="\u05e2\u05d1\u05e8\u05d9\u05ea")
+        sf = fmt.SeriesFormatter(s, name="\u05e2\u05d1\u05e8\u05d9\u05ea")
+        sf._get_footer()  # should not raise exception
+
+    @pytest.mark.xfail(
+        using_pyarrow_string_dtype(), reason="Fixup when arrow is default"
+    )
+    def test_east_asian_unicode_series(self):
+        # not aligned properly because of east asian width
+
+        # unicode index
+        s = Series(["a", "bb", "CCC", "D"], index=["あ", "いい", "ううう", "ええええ"])
+        expected = "".join(
+            [
+                "あ         a\n",
+                "いい       bb\n",
+                "ううう     CCC\n",
+                "ええええ      D\ndtype: object",
+            ]
+        )
+        assert repr(s) == expected
+
+        # unicode values
+        s = Series(["あ", "いい", "ううう", "ええええ"], index=["a", "bb", "c", "ddd"])
+        expected = "".join(
+            [
+                "a         あ\n",
+                "bb       いい\n",
+                "c       ううう\n",
+                "ddd    ええええ\n",
+                "dtype: object",
+            ]
+        )
+
+        assert repr(s) == expected
+
+        # both
+        s = Series(
+            ["あ", "いい", "ううう", "ええええ"],
+            index=["ああ", "いいいい", "う", "えええ"],
+        )
+        expected = "".join(
+            [
+                "ああ         あ\n",
+                "いいいい      いい\n",
+                "う        ううう\n",
+                "えええ     ええええ\n",
+                "dtype: object",
+            ]
+        )
+
+        assert repr(s) == expected
+
+        # unicode footer
+        s = Series(
+            ["あ", "いい", "ううう", "ええええ"],
+            index=["ああ", "いいいい", "う", "えええ"],
+            name="おおおおおおお",
+        )
+        expected = (
+            "ああ         あ\nいいいい      いい\nう        ううう\n"
+            "えええ     ええええ\nName: おおおおおおお, dtype: object"
+        )
+        assert repr(s) == expected
+
+        # MultiIndex
+        idx = MultiIndex.from_tuples(
+            [("あ", "いい"), ("う", "え"), ("おおお", "かかかか"), ("き", "くく")]
+        )
+        s = Series([1, 22, 3333, 44444], index=idx)
+        expected = (
+            "あ    いい          1\n"
+            "う    え          22\n"
+            "おおお  かかかか     3333\n"
+            "き    くく      44444\ndtype: int64"
+        )
+        assert repr(s) == expected
+
+        # object dtype, shorter than unicode repr
+        s = Series([1, 22, 3333, 44444], index=[1, "AB", np.nan, "あああ"])
+        expected = (
+            "1          1\nAB        22\nNaN     3333\nあああ    44444\ndtype: int64"
+        )
+        assert repr(s) == expected
+
+        # object dtype, longer than unicode repr
+        s = Series(
+            [1, 22, 3333, 44444], index=[1, "AB", Timestamp("2011-01-01"), "あああ"]
+        )
+        expected = (
+            "1                          1\n"
+            "AB                        22\n"
+            "2011-01-01 00:00:00     3333\n"
+            "あああ                    44444\ndtype: int64"
+        )
+        assert repr(s) == expected
+
+        # truncate
+        with option_context("display.max_rows", 3):
+            s = Series(["あ", "いい", "ううう", "ええええ"], name="おおおおおおお")
+
+            expected = (
+                "0       あ\n     ... \n"
+                "3    ええええ\n"
+                "Name: おおおおおおお, Length: 4, dtype: object"
+            )
+            assert repr(s) == expected
+
+            s.index = ["ああ", "いいいい", "う", "えええ"]
+            expected = (
+                "ああ        あ\n       ... \n"
+                "えええ    ええええ\n"
+                "Name: おおおおおおお, Length: 4, dtype: object"
+            )
+            assert repr(s) == expected
+
+        # Enable Unicode option -----------------------------------------
+        with option_context("display.unicode.east_asian_width", True):
+            # unicode index
+            s = Series(
+                ["a", "bb", "CCC", "D"],
+                index=["あ", "いい", "ううう", "ええええ"],
+            )
+            expected = (
+                "あ            a\nいい         bb\nううう      CCC\n"
+                "ええええ      D\ndtype: object"
+            )
+            assert repr(s) == expected
+
+            # unicode values
+            s = Series(
+                ["あ", "いい", "ううう", "ええええ"],
+                index=["a", "bb", "c", "ddd"],
+            )
+            expected = (
+                "a            あ\nbb         いい\nc        ううう\n"
+                "ddd    ええええ\ndtype: object"
+            )
+            assert repr(s) == expected
+            # both
+            s = Series(
+                ["あ", "いい", "ううう", "ええええ"],
+                index=["ああ", "いいいい", "う", "えええ"],
+            )
+            expected = (
+                "ああ              あ\n"
+                "いいいい        いい\n"
+                "う            ううう\n"
+                "えええ      ええええ\ndtype: object"
+            )
+            assert repr(s) == expected
+
+            # unicode footer
+            s = Series(
+                ["あ", "いい", "ううう", "ええええ"],
+                index=["ああ", "いいいい", "う", "えええ"],
+                name="おおおおおおお",
+            )
+            expected = (
+                "ああ              あ\n"
+                "いいいい        いい\n"
+                "う            ううう\n"
+                "えええ      ええええ\n"
+                "Name: おおおおおおお, dtype: object"
+            )
+            assert repr(s) == expected
+
+            # MultiIndex
+            idx = MultiIndex.from_tuples(
+                [("あ", "いい"), ("う", "え"), ("おおお", "かかかか"), ("き", "くく")]
+            )
+            s = Series([1, 22, 3333, 44444], index=idx)
+            expected = (
+                "あ      いい            1\n"
+                "う      え             22\n"
+                "おおお  かかかか     3333\n"
+                "き      くく        44444\n"
+                "dtype: int64"
+            )
+            assert repr(s) == expected
+
+            # object dtype, shorter than unicode repr
+            s = Series([1, 22, 3333, 44444], index=[1, "AB", np.nan, "あああ"])
+            expected = (
+                "1             1\nAB           22\nNaN        3333\n"
+                "あああ    44444\ndtype: int64"
+            )
+            assert repr(s) == expected
+
+            # object dtype, longer than unicode repr
+            s = Series(
+                [1, 22, 3333, 44444],
+                index=[1, "AB", Timestamp("2011-01-01"), "あああ"],
+            )
+            expected = (
+                "1                          1\n"
+                "AB                        22\n"
+                "2011-01-01 00:00:00     3333\n"
+                "あああ                 44444\ndtype: int64"
+            )
+            assert repr(s) == expected
+
+            # truncate
+            with option_context("display.max_rows", 3):
+                s = Series(["あ", "いい", "ううう", "ええええ"], name="おおおおおおお")
+                expected = (
+                    "0          あ\n       ...   \n"
+                    "3    ええええ\n"
+                    "Name: おおおおおおお, Length: 4, dtype: object"
+                )
+                assert repr(s) == expected
+
+                s.index = ["ああ", "いいいい", "う", "えええ"]
+                expected = (
+                    "ああ            あ\n"
+                    "            ...   \n"
+                    "えええ    ええええ\n"
+                    "Name: おおおおおおお, Length: 4, dtype: object"
+                )
+                assert repr(s) == expected
+
+            # ambiguous unicode
+            s = Series(
+                ["¡¡", "い¡¡", "ううう", "ええええ"],
+                index=["ああ", "¡¡¡¡いい", "¡¡", "えええ"],
+            )
+            expected = (
+                "ああ              ¡¡\n"
+                "¡¡¡¡いい        い¡¡\n"
+                "¡¡            ううう\n"
+                "えええ      ええええ\ndtype: object"
+            )
+            assert repr(s) == expected
+
+    def test_float_trim_zeros(self):
+        vals = [
+            2.08430917305e10,
+            3.52205017305e10,
+            2.30674817305e10,
+            2.03954217305e10,
+            5.59897817305e10,
+        ]
+        for line in repr(Series(vals)).split("\n"):
+            if line.startswith("dtype:"):
+                continue
+            if _three_digit_exp():
+                assert "+010" in line
+            else:
+                assert "+10" in line
+
+    @pytest.mark.parametrize(
+        "start_date",
+        [
+            "2017-01-01 23:59:59.999999999",
+            "2017-01-01 23:59:59.99999999",
+            "2017-01-01 23:59:59.9999999",
+            "2017-01-01 23:59:59.999999",
+            "2017-01-01 23:59:59.99999",
+            "2017-01-01 23:59:59.9999",
+        ],
+    )
+    def test_datetimeindex_highprecision(self, start_date):
+        # GH19030
+        # Check that high-precision time values for the end of day are
+        # included in repr for DatetimeIndex
+        s1 = Series(date_range(start=start_date, freq="D", periods=5))
+        result = str(s1)
+        assert start_date in result
+
+        dti = date_range(start=start_date, freq="D", periods=5)
+        s2 = Series(3, index=dti)
+        result = str(s2.index)
+        assert start_date in result
+
+    def test_mixed_datetime64(self):
+        df = DataFrame({"A": [1, 2], "B": ["2012-01-01", "2012-01-02"]})
+        df["B"] = pd.to_datetime(df.B)
+
+        result = repr(df.loc[0])
+        assert "2012-01-01" in result
+
+    def test_period(self):
+        # GH 12615
+        index = pd.period_range("2013-01", periods=6, freq="M")
+        s = Series(np.arange(6, dtype="int64"), index=index)
+        exp = (
+            "2013-01    0\n"
+            "2013-02    1\n"
+            "2013-03    2\n"
+            "2013-04    3\n"
+            "2013-05    4\n"
+            "2013-06    5\n"
+            "Freq: M, dtype: int64"
+        )
+        assert str(s) == exp
+
+        s = Series(index)
+        exp = (
+            "0    2013-01\n"
+            "1    2013-02\n"
+            "2    2013-03\n"
+            "3    2013-04\n"
+            "4    2013-05\n"
+            "5    2013-06\n"
+            "dtype: period[M]"
+        )
+        assert str(s) == exp
+
+        # periods with mixed freq
+        s = Series(
+            [
+                pd.Period("2011-01", freq="M"),
+                pd.Period("2011-02-01", freq="D"),
+                pd.Period("2011-03-01 09:00", freq="h"),
+            ]
+        )
+        exp = (
+            "0             2011-01\n1          2011-02-01\n"
+            "2    2011-03-01 09:00\ndtype: object"
+        )
+        assert str(s) == exp
+
+    def test_max_multi_index_display(self):
+        # GH 7101
+
+        # doc example (indexing.rst)
+
+        # multi-index
+        arrays = [
+            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+            ["one", "two", "one", "two", "one", "two", "one", "two"],
+        ]
+        tuples = list(zip(*arrays))
+        index = MultiIndex.from_tuples(tuples, names=["first", "second"])
+        s = Series(np.random.default_rng(2).standard_normal(8), index=index)
+
+        with option_context("display.max_rows", 10):
+            assert len(str(s).split("\n")) == 10
+        with option_context("display.max_rows", 3):
+            assert len(str(s).split("\n")) == 5
+        with option_context("display.max_rows", 2):
+            assert len(str(s).split("\n")) == 5
+        with option_context("display.max_rows", 1):
+            assert len(str(s).split("\n")) == 4
+        with option_context("display.max_rows", 0):
+            assert len(str(s).split("\n")) == 10
+
+        # index
+        s = Series(np.random.default_rng(2).standard_normal(8), None)
+
+        with option_context("display.max_rows", 10):
+            assert len(str(s).split("\n")) == 9
+        with option_context("display.max_rows", 3):
+            assert len(str(s).split("\n")) == 4
+        with option_context("display.max_rows", 2):
+            assert len(str(s).split("\n")) == 4
+        with option_context("display.max_rows", 1):
+            assert len(str(s).split("\n")) == 3
+        with option_context("display.max_rows", 0):
+            assert len(str(s).split("\n")) == 9
+
+    # Make sure #8532 is fixed
+    def test_consistent_format(self):
+        s = Series([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0.9999, 1, 1] * 10)
+        with option_context("display.max_rows", 10, "display.show_dimensions", False):
+            res = repr(s)
+        exp = (
+            "0      1.0000\n1      1.0000\n2      1.0000\n3      "
+            "1.0000\n4      1.0000\n        ...  \n125    "
+            "1.0000\n126    1.0000\n127    0.9999\n128    "
+            "1.0000\n129    1.0000\ndtype: float64"
+        )
+        assert res == exp
+
+    def chck_ncols(self, s):
+        lines = [
+            line for line in repr(s).split("\n") if not re.match(r"[^\.]*\.+", line)
+        ][:-1]
+        ncolsizes = len({len(line.strip()) for line in lines})
+        assert ncolsizes == 1
+
+    @pytest.mark.xfail(
+        using_pyarrow_string_dtype(), reason="change when arrow is default"
+    )
+    def test_format_explicit(self):
+        test_sers = gen_series_formatting()
+        with option_context("display.max_rows", 4, "display.show_dimensions", False):
+            res = repr(test_sers["onel"])
+            exp = "0     a\n1     a\n     ..\n98    a\n99    a\ndtype: object"
+            assert exp == res
+            res = repr(test_sers["twol"])
+            exp = "0     ab\n1     ab\n      ..\n98    ab\n99    ab\ndtype: object"
+            assert exp == res
+            res = repr(test_sers["asc"])
+            exp = (
+                "0         a\n1        ab\n      ...  \n4     abcde\n5    "
+                "abcdef\ndtype: object"
+            )
+            assert exp == res
+            res = repr(test_sers["desc"])
+            exp = (
+                "5    abcdef\n4     abcde\n      ...  \n1        ab\n0         "
+                "a\ndtype: object"
+            )
+            assert exp == res
+
+    def test_ncols(self):
+        test_sers = gen_series_formatting()
+        for s in test_sers.values():
+            self.chck_ncols(s)
+
+    def test_max_rows_eq_one(self):
+        s = Series(range(10), dtype="int64")
+        with option_context("display.max_rows", 1):
+            strrepr = repr(s).split("\n")
+        exp1 = ["0", "0"]
+        res1 = strrepr[0].split()
+        assert exp1 == res1
+        exp2 = [".."]
+        res2 = strrepr[1].split()
+        assert exp2 == res2
+
+    def test_truncate_ndots(self):
+        def getndots(s):
+            return len(re.match(r"[^\.]*(\.*)", s).groups()[0])
+
+        s = Series([0, 2, 3, 6])
+        with option_context("display.max_rows", 2):
+            strrepr = repr(s).replace("\n", "")
+        assert getndots(strrepr) == 2
+
+        s = Series([0, 100, 200, 400])
+        with option_context("display.max_rows", 2):
+            strrepr = repr(s).replace("\n", "")
+        assert getndots(strrepr) == 3
+
+    def test_show_dimensions(self):
+        # gh-7117
+        s = Series(range(5))
+
+        assert "Length" not in repr(s)
+
+        with option_context("display.max_rows", 4):
+            assert "Length" in repr(s)
+
+        with option_context("display.show_dimensions", True):
+            assert "Length" in repr(s)
+
+        with option_context("display.max_rows", 4, "display.show_dimensions", False):
+            assert "Length" not in repr(s)
+
+    def test_repr_min_rows(self):
+        s = Series(range(20))
+
+        # default setting no truncation even if above min_rows
+        assert ".." not in repr(s)
+
+        s = Series(range(61))
+
+        # default of max_rows 60 triggers truncation if above
+        assert ".." in repr(s)
+
+        with option_context("display.max_rows", 10, "display.min_rows", 4):
+            # truncated after first two rows
+            assert ".." in repr(s)
+            assert "2  " not in repr(s)
+
+        with option_context("display.max_rows", 12, "display.min_rows", None):
+            # when set to None, follow value of max_rows
+            assert "5      5" in repr(s)
+
+        with option_context("display.max_rows", 10, "display.min_rows", 12):
+            # when set value higher as max_rows, use the minimum
+            assert "5      5" not in repr(s)
+
+        with option_context("display.max_rows", None, "display.min_rows", 12):
+            # max_rows of None -> never truncate
+            assert ".." not in repr(s)
+
+
+class TestGenericArrayFormatter:
+    def test_1d_array(self):
+        # _GenericArrayFormatter is used on types for which there isn't a dedicated
+        # formatter. np.bool_ is one of those types.
+        obj = fmt._GenericArrayFormatter(np.array([True, False]))
+        res = obj.get_result()
+        assert len(res) == 2
+        # Results should be right-justified.
+        assert res[0] == "  True"
+        assert res[1] == " False"
+
+    def test_2d_array(self):
+        obj = fmt._GenericArrayFormatter(np.array([[True, False], [False, True]]))
+        res = obj.get_result()
+        assert len(res) == 2
+        assert res[0] == " [True, False]"
+        assert res[1] == " [False, True]"
+
+    def test_3d_array(self):
+        obj = fmt._GenericArrayFormatter(
+            np.array([[[True, True], [False, False]], [[False, True], [True, False]]])
+        )
+        res = obj.get_result()
+        assert len(res) == 2
+        assert res[0] == " [[True, True], [False, False]]"
+        assert res[1] == " [[False, True], [True, False]]"
+
+    def test_2d_extension_type(self):
+        # GH 33770
+
+        # Define a stub extension type with just enough code to run Series.__repr__()
+        class DtypeStub(pd.api.extensions.ExtensionDtype):
+            @property
+            def type(self):
+                return np.ndarray
+
+            @property
+            def name(self):
+                return "DtypeStub"
+
+        class ExtTypeStub(pd.api.extensions.ExtensionArray):
+            def __len__(self) -> int:
+                return 2
+
+            def __getitem__(self, ix):
+                return [ix == 1, ix == 0]
+
+            @property
+            def dtype(self):
+                return DtypeStub()
+
+        series = Series(ExtTypeStub(), copy=False)
+        res = repr(series)  # This line crashed before #33770 was fixed.
+        expected = "\n".join(
+            ["0    [False True]", "1    [True False]", "dtype: DtypeStub"]
+        )
+        assert res == expected
+
+
+def _three_digit_exp():
+    return f"{1.7e8:.4g}" == "1.7e+008"
+
+
+class TestFloatArrayFormatter:
+    def test_misc(self):
+        obj = fmt.FloatArrayFormatter(np.array([], dtype=np.float64))
+        result = obj.get_result()
+        assert len(result) == 0
+
+    def test_format(self):
+        obj = fmt.FloatArrayFormatter(np.array([12, 0], dtype=np.float64))
+        result = obj.get_result()
+        assert result[0] == " 12.0"
+        assert result[1] == "  0.0"
+
+    def test_output_display_precision_trailing_zeroes(self):
+        # Issue #20359: trimming zeros while there is no decimal point
+
+        # Happens when display precision is set to zero
+        with option_context("display.precision", 0):
+            s = Series([840.0, 4200.0])
+            expected_output = "0     840\n1    4200\ndtype: float64"
+            assert str(s) == expected_output
+
+    @pytest.mark.parametrize(
+        "value,expected",
+        [
+            ([9.4444], "   0\n0  9"),
+            ([0.49], "       0\n0  5e-01"),
+            ([10.9999], "    0\n0  11"),
+            ([9.5444, 9.6], "    0\n0  10\n1  10"),
+            ([0.46, 0.78, -9.9999], "       0\n0  5e-01\n1  8e-01\n2 -1e+01"),
+        ],
+    )
+    def test_set_option_precision(self, value, expected):
+        # Issue #30122
+        # Precision was incorrectly shown
+
+        with option_context("display.precision", 0):
+            df_value = DataFrame(value)
+            assert str(df_value) == expected
+
+    def test_output_significant_digits(self):
+        # Issue #9764
+
+        # In case default display precision changes:
+        with option_context("display.precision", 6):
+            # DataFrame example from issue #9764
+            d = DataFrame(
+                {
+                    "col1": [
+                        9.999e-8,
+                        1e-7,
+                        1.0001e-7,
+                        2e-7,
+                        4.999e-7,
+                        5e-7,
+                        5.0001e-7,
+                        6e-7,
+                        9.999e-7,
+                        1e-6,
+                        1.0001e-6,
+                        2e-6,
+                        4.999e-6,
+                        5e-6,
+                        5.0001e-6,
+                        6e-6,
+                    ]
+                }
+            )
+
+            expected_output = {
+                (0, 6): "           col1\n"
+                "0  9.999000e-08\n"
+                "1  1.000000e-07\n"
+                "2  1.000100e-07\n"
+                "3  2.000000e-07\n"
+                "4  4.999000e-07\n"
+                "5  5.000000e-07",
+                (1, 6): "           col1\n"
+                "1  1.000000e-07\n"
+                "2  1.000100e-07\n"
+                "3  2.000000e-07\n"
+                "4  4.999000e-07\n"
+                "5  5.000000e-07",
+                (1, 8): "           col1\n"
+                "1  1.000000e-07\n"
+                "2  1.000100e-07\n"
+                "3  2.000000e-07\n"
+                "4  4.999000e-07\n"
+                "5  5.000000e-07\n"
+                "6  5.000100e-07\n"
+                "7  6.000000e-07",
+                (8, 16): "            col1\n"
+                "8   9.999000e-07\n"
+                "9   1.000000e-06\n"
+                "10  1.000100e-06\n"
+                "11  2.000000e-06\n"
+                "12  4.999000e-06\n"
+                "13  5.000000e-06\n"
+                "14  5.000100e-06\n"
+                "15  6.000000e-06",
+                (9, 16): "        col1\n"
+                "9   0.000001\n"
+                "10  0.000001\n"
+                "11  0.000002\n"
+                "12  0.000005\n"
+                "13  0.000005\n"
+                "14  0.000005\n"
+                "15  0.000006",
+            }
+
+            for (start, stop), v in expected_output.items():
+                assert str(d[start:stop]) == v
+
+    def test_too_long(self):
+        # GH 10451
+        with option_context("display.precision", 4):
+            # need both a number > 1e6 and something that normally formats to
+            # having length > display.precision + 6
+            df = DataFrame({"x": [12345.6789]})
+            assert str(df) == "            x\n0  12345.6789"
+            df = DataFrame({"x": [2e6]})
+            assert str(df) == "           x\n0  2000000.0"
+            df = DataFrame({"x": [12345.6789, 2e6]})
+            assert str(df) == "            x\n0  1.2346e+04\n1  2.0000e+06"
+
+
+class TestTimedelta64Formatter:
+    def test_days(self):
+        x = pd.to_timedelta(list(range(5)) + [NaT], unit="D")._values
+        result = fmt._Timedelta64Formatter(x).get_result()
+        assert result[0].strip() == "0 days"
+        assert result[1].strip() == "1 days"
+
+        result = fmt._Timedelta64Formatter(x[1:2]).get_result()
+        assert result[0].strip() == "1 days"
+
+        result = fmt._Timedelta64Formatter(x).get_result()
+        assert result[0].strip() == "0 days"
+        assert result[1].strip() == "1 days"
+
+        result = fmt._Timedelta64Formatter(x[1:2]).get_result()
+        assert result[0].strip() == "1 days"
+
+    def test_days_neg(self):
+        x = pd.to_timedelta(list(range(5)) + [NaT], unit="D")._values
+        result = fmt._Timedelta64Formatter(-x).get_result()
+        assert result[0].strip() == "0 days"
+        assert result[1].strip() == "-1 days"
+
+    def test_subdays(self):
+        y = pd.to_timedelta(list(range(5)) + [NaT], unit="s")._values
+        result = fmt._Timedelta64Formatter(y).get_result()
+        assert result[0].strip() == "0 days 00:00:00"
+        assert result[1].strip() == "0 days 00:00:01"
+
+    def test_subdays_neg(self):
+        y = pd.to_timedelta(list(range(5)) + [NaT], unit="s")._values
+        result = fmt._Timedelta64Formatter(-y).get_result()
+        assert result[0].strip() == "0 days 00:00:00"
+        assert result[1].strip() == "-1 days +23:59:59"
+
+    def test_zero(self):
+        x = pd.to_timedelta(list(range(1)) + [NaT], unit="D")._values
+        result = fmt._Timedelta64Formatter(x).get_result()
+        assert result[0].strip() == "0 days"
+
+        x = pd.to_timedelta(list(range(1)), unit="D")._values
+        result = fmt._Timedelta64Formatter(x).get_result()
+        assert result[0].strip() == "0 days"
+
+
+class TestDatetime64Formatter:
+    def test_mixed(self):
+        x = Series([datetime(2013, 1, 1), datetime(2013, 1, 1, 12), NaT])._values
+        result = fmt._Datetime64Formatter(x).get_result()
+        assert result[0].strip() == "2013-01-01 00:00:00"
+        assert result[1].strip() == "2013-01-01 12:00:00"
+
+    def test_dates(self):
+        x = Series([datetime(2013, 1, 1), datetime(2013, 1, 2), NaT])._values
+        result = fmt._Datetime64Formatter(x).get_result()
+        assert result[0].strip() == "2013-01-01"
+        assert result[1].strip() == "2013-01-02"
+
+    def test_date_nanos(self):
+        x = Series([Timestamp(200)])._values
+        result = fmt._Datetime64Formatter(x).get_result()
+        assert result[0].strip() == "1970-01-01 00:00:00.000000200"
+
+    def test_dates_display(self):
+        # 10170
+        # make sure that we are consistently display date formatting
+        x = Series(date_range("20130101 09:00:00", periods=5, freq="D"))
+        x.iloc[1] = np.nan
+        result = fmt._Datetime64Formatter(x._values).get_result()
+        assert result[0].strip() == "2013-01-01 09:00:00"
+        assert result[1].strip() == "NaT"
+        assert result[4].strip() == "2013-01-05 09:00:00"
+
+        x = Series(date_range("20130101 09:00:00", periods=5, freq="s"))
+        x.iloc[1] = np.nan
+        result = fmt._Datetime64Formatter(x._values).get_result()
+        assert result[0].strip() == "2013-01-01 09:00:00"
+        assert result[1].strip() == "NaT"
+        assert result[4].strip() == "2013-01-01 09:00:04"
+
+        x = Series(date_range("20130101 09:00:00", periods=5, freq="ms"))
+        x.iloc[1] = np.nan
+        result = fmt._Datetime64Formatter(x._values).get_result()
+        assert result[0].strip() == "2013-01-01 09:00:00.000"
+        assert result[1].strip() == "NaT"
+        assert result[4].strip() == "2013-01-01 09:00:00.004"
+
+        x = Series(date_range("20130101 09:00:00", periods=5, freq="us"))
+        x.iloc[1] = np.nan
+        result = fmt._Datetime64Formatter(x._values).get_result()
+        assert result[0].strip() == "2013-01-01 09:00:00.000000"
+        assert result[1].strip() == "NaT"
+        assert result[4].strip() == "2013-01-01 09:00:00.000004"
+
+        x = Series(date_range("20130101 09:00:00", periods=5, freq="ns"))
+        x.iloc[1] = np.nan
+        result = fmt._Datetime64Formatter(x._values).get_result()
+        assert result[0].strip() == "2013-01-01 09:00:00.000000000"
+        assert result[1].strip() == "NaT"
+        assert result[4].strip() == "2013-01-01 09:00:00.000000004"
+
+    def test_datetime64formatter_yearmonth(self):
+        x = Series([datetime(2016, 1, 1), datetime(2016, 2, 2)])._values
+
+        def format_func(x):
+            return x.strftime("%Y-%m")
+
+        formatter = fmt._Datetime64Formatter(x, formatter=format_func)
+        result = formatter.get_result()
+        assert result == ["2016-01", "2016-02"]
+
+    def test_datetime64formatter_hoursecond(self):
+        x = Series(
+            pd.to_datetime(["10:10:10.100", "12:12:12.120"], format="%H:%M:%S.%f")
+        )._values
+
+        def format_func(x):
+            return x.strftime("%H:%M")
+
+        formatter = fmt._Datetime64Formatter(x, formatter=format_func)
+        result = formatter.get_result()
+        assert result == ["10:10", "12:12"]
+
+    def test_datetime64formatter_tz_ms(self):
+        x = (
+            Series(
+                np.array(["2999-01-01", "2999-01-02", "NaT"], dtype="datetime64[ms]")
+            )
+            .dt.tz_localize("US/Pacific")
+            ._values
+        )
+        result = fmt._Datetime64TZFormatter(x).get_result()
+        assert result[0].strip() == "2999-01-01 00:00:00-08:00"
+        assert result[1].strip() == "2999-01-02 00:00:00-08:00"
+
+
+class TestFormatPercentiles:
+    @pytest.mark.parametrize(
+        "percentiles, expected",
+        [
+            (
+                [0.01999, 0.02001, 0.5, 0.666666, 0.9999],
+                ["1.999%", "2.001%", "50%", "66.667%", "99.99%"],
+            ),
+            (
+                [0, 0.5, 0.02001, 0.5, 0.666666, 0.9999],
+                ["0%", "50%", "2.0%", "50%", "66.67%", "99.99%"],
+            ),
+            ([0.281, 0.29, 0.57, 0.58], ["28.1%", "29%", "57%", "58%"]),
+            ([0.28, 0.29, 0.57, 0.58], ["28%", "29%", "57%", "58%"]),
+            (
+                [0.9, 0.99, 0.999, 0.9999, 0.99999],
+                ["90%", "99%", "99.9%", "99.99%", "99.999%"],
+            ),
+        ],
+    )
+    def test_format_percentiles(self, percentiles, expected):
+        result = fmt.format_percentiles(percentiles)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "percentiles",
+        [
+            ([0.1, np.nan, 0.5]),
+            ([-0.001, 0.1, 0.5]),
+            ([2, 0.1, 0.5]),
+            ([0.1, 0.5, "a"]),
+        ],
+    )
+    def test_error_format_percentiles(self, percentiles):
+        msg = r"percentiles should all be in the interval \[0,1\]"
+        with pytest.raises(ValueError, match=msg):
+            fmt.format_percentiles(percentiles)
+
+    def test_format_percentiles_integer_idx(self):
+        # Issue #26660
+        result = fmt.format_percentiles(np.linspace(0, 1, 10 + 1))
+        expected = [
+            "0%",
+            "10%",
+            "20%",
+            "30%",
+            "40%",
+            "50%",
+            "60%",
+            "70%",
+            "80%",
+            "90%",
+            "100%",
+        ]
+        assert result == expected
+
+
+@pytest.mark.parametrize("method", ["to_string", "to_html", "to_latex"])
+@pytest.mark.parametrize(
+    "encoding, data",
+    [(None, "abc"), ("utf-8", "abc"), ("gbk", "造成输出中文显示乱码"), ("foo", "abc")],
+)
+def test_filepath_or_buffer_arg(
+    method,
+    filepath_or_buffer,
+    assert_filepath_or_buffer_equals,
+    encoding,
+    data,
+    filepath_or_buffer_id,
+):
+    df = DataFrame([data])
+    if method in ["to_latex"]:  # uses styler implementation
+        pytest.importorskip("jinja2")
+
+    if filepath_or_buffer_id not in ["string", "pathlike"] and encoding is not None:
+        with pytest.raises(
+            ValueError, match="buf is not a file name and encoding is specified."
+        ):
+            getattr(df, method)(buf=filepath_or_buffer, encoding=encoding)
+    elif encoding == "foo":
+        with pytest.raises(LookupError, match="unknown encoding"):
+            getattr(df, method)(buf=filepath_or_buffer, encoding=encoding)
+    else:
+        expected = getattr(df, method)()
+        getattr(df, method)(buf=filepath_or_buffer, encoding=encoding)
+        assert_filepath_or_buffer_equals(expected)
+
+
+@pytest.mark.parametrize("method", ["to_string", "to_html", "to_latex"])
+def test_filepath_or_buffer_bad_arg_raises(float_frame, method):
+    if method in ["to_latex"]:  # uses styler implementation
+        pytest.importorskip("jinja2")
+    msg = "buf is not a file name and it has no write method"
+    with pytest.raises(TypeError, match=msg):
+        getattr(float_frame, method)(buf=object())

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/test_ipython_compat.py

@@ -0,0 +1,90 @@
+import numpy as np
+
+import pandas._config.config as cf
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+)
+
+
+class TestTableSchemaRepr:
+    def test_publishes(self, ip):
+        ipython = ip.instance(config=ip.config)
+        df = DataFrame({"A": [1, 2]})
+        objects = [df["A"], df]  # dataframe / series
+        expected_keys = [
+            {"text/plain", "application/vnd.dataresource+json"},
+            {"text/plain", "text/html", "application/vnd.dataresource+json"},
+        ]
+
+        opt = cf.option_context("display.html.table_schema", True)
+        last_obj = None
+        for obj, expected in zip(objects, expected_keys):
+            last_obj = obj
+            with opt:
+                formatted = ipython.display_formatter.format(obj)
+            assert set(formatted[0].keys()) == expected
+
+        with_latex = cf.option_context("styler.render.repr", "latex")
+
+        with opt, with_latex:
+            formatted = ipython.display_formatter.format(last_obj)
+
+        expected = {
+            "text/plain",
+            "text/html",
+            "text/latex",
+            "application/vnd.dataresource+json",
+        }
+        assert set(formatted[0].keys()) == expected
+
+    def test_publishes_not_implemented(self, ip):
+        # column MultiIndex
+        # GH#15996
+        midx = MultiIndex.from_product([["A", "B"], ["a", "b", "c"]])
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((5, len(midx))), columns=midx
+        )
+
+        opt = cf.option_context("display.html.table_schema", True)
+
+        with opt:
+            formatted = ip.instance(config=ip.config).display_formatter.format(df)
+
+        expected = {"text/plain", "text/html"}
+        assert set(formatted[0].keys()) == expected
+
+    def test_config_on(self):
+        df = DataFrame({"A": [1, 2]})
+        with cf.option_context("display.html.table_schema", True):
+            result = df._repr_data_resource_()
+
+        assert result is not None
+
+    def test_config_default_off(self):
+        df = DataFrame({"A": [1, 2]})
+        with cf.option_context("display.html.table_schema", False):
+            result = df._repr_data_resource_()
+
+        assert result is None
+
+    def test_enable_data_resource_formatter(self, ip):
+        # GH#10491
+        formatters = ip.instance(config=ip.config).display_formatter.formatters
+        mimetype = "application/vnd.dataresource+json"
+
+        with cf.option_context("display.html.table_schema", True):
+            assert "application/vnd.dataresource+json" in formatters
+            assert formatters[mimetype].enabled
+
+        # still there, just disabled
+        assert "application/vnd.dataresource+json" in formatters
+        assert not formatters[mimetype].enabled
+
+        # able to re-set
+        with cf.option_context("display.html.table_schema", True):
+            assert "application/vnd.dataresource+json" in formatters
+            assert formatters[mimetype].enabled
+            # smoke test that it works
+            ip.instance(config=ip.config).display_formatter.format(cf)

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/formats/test_printing.py

@@ -0,0 +1,129 @@
+# Note! This file is aimed specifically at pandas.io.formats.printing utility
+# functions, not the general printing of pandas objects.
+import string
+
+import pandas._config.config as cf
+
+from pandas.io.formats import printing
+
+
+def test_adjoin():
+    data = [["a", "b", "c"], ["dd", "ee", "ff"], ["ggg", "hhh", "iii"]]
+    expected = "a  dd  ggg\nb  ee  hhh\nc  ff  iii"
+
+    adjoined = printing.adjoin(2, *data)
+
+    assert adjoined == expected
+
+
+class TestPPrintThing:
+    def test_repr_binary_type(self):
+        letters = string.ascii_letters
+        try:
+            raw = bytes(letters, encoding=cf.get_option("display.encoding"))
+        except TypeError:
+            raw = bytes(letters)
+        b = str(raw.decode("utf-8"))
+        res = printing.pprint_thing(b, quote_strings=True)
+        assert res == repr(b)
+        res = printing.pprint_thing(b, quote_strings=False)
+        assert res == b
+
+    def test_repr_obeys_max_seq_limit(self):
+        with cf.option_context("display.max_seq_items", 2000):
+            assert len(printing.pprint_thing(list(range(1000)))) > 1000
+
+        with cf.option_context("display.max_seq_items", 5):
+            assert len(printing.pprint_thing(list(range(1000)))) < 100
+
+        with cf.option_context("display.max_seq_items", 1):
+            assert len(printing.pprint_thing(list(range(1000)))) < 9
+
+    def test_repr_set(self):
+        assert printing.pprint_thing({1}) == "{1}"
+
+
+class TestFormatBase:
+    def test_adjoin(self):
+        data = [["a", "b", "c"], ["dd", "ee", "ff"], ["ggg", "hhh", "iii"]]
+        expected = "a  dd  ggg\nb  ee  hhh\nc  ff  iii"
+
+        adjoined = printing.adjoin(2, *data)
+
+        assert adjoined == expected
+
+    def test_adjoin_unicode(self):
+        data = [["あ", "b", "c"], ["dd", "ええ", "ff"], ["ggg", "hhh", "いいい"]]
+        expected = "あ  dd  ggg\nb  ええ  hhh\nc  ff  いいい"
+        adjoined = printing.adjoin(2, *data)
+        assert adjoined == expected
+
+        adj = printing._EastAsianTextAdjustment()
+
+        expected = """あ  dd    ggg
+b   ええ  hhh
+c   ff    いいい"""
+
+        adjoined = adj.adjoin(2, *data)
+        assert adjoined == expected
+        cols = adjoined.split("\n")
+        assert adj.len(cols[0]) == 13
+        assert adj.len(cols[1]) == 13
+        assert adj.len(cols[2]) == 16
+
+        expected = """あ       dd         ggg
+b        ええ       hhh
+c        ff         いいい"""
+
+        adjoined = adj.adjoin(7, *data)
+        assert adjoined == expected
+        cols = adjoined.split("\n")
+        assert adj.len(cols[0]) == 23
+        assert adj.len(cols[1]) == 23
+        assert adj.len(cols[2]) == 26
+
+    def test_justify(self):
+        adj = printing._EastAsianTextAdjustment()
+
+        def just(x, *args, **kwargs):
+            # wrapper to test single str
+            return adj.justify([x], *args, **kwargs)[0]
+
+        assert just("abc", 5, mode="left") == "abc  "
+        assert just("abc", 5, mode="center") == " abc "
+        assert just("abc", 5, mode="right") == "  abc"
+        assert just("abc", 5, mode="left") == "abc  "
+        assert just("abc", 5, mode="center") == " abc "
+        assert just("abc", 5, mode="right") == "  abc"
+
+        assert just("パンダ", 5, mode="left") == "パンダ"
+        assert just("パンダ", 5, mode="center") == "パンダ"
+        assert just("パンダ", 5, mode="right") == "パンダ"
+
+        assert just("パンダ", 10, mode="left") == "パンダ    "
+        assert just("パンダ", 10, mode="center") == "  パンダ  "
+        assert just("パンダ", 10, mode="right") == "    パンダ"
+
+    def test_east_asian_len(self):
+        adj = printing._EastAsianTextAdjustment()
+
+        assert adj.len("abc") == 3
+        assert adj.len("abc") == 3
+
+        assert adj.len("パンダ") == 6
+        assert adj.len("ﾊﾟﾝﾀﾞ") == 5
+        assert adj.len("パンダpanda") == 11
+        assert adj.len("ﾊﾟﾝﾀﾞpanda") == 10
+
+    def test_ambiguous_width(self):
+        adj = printing._EastAsianTextAdjustment()
+        assert adj.len("¡¡ab") == 4
+
+        with cf.option_context("display.unicode.ambiguous_as_wide", True):
+            adj = printing._EastAsianTextAdjustment()
+            assert adj.len("¡¡ab") == 6
+
+        data = [["あ", "b", "c"], ["dd", "ええ", "ff"], ["ggg", "¡¡ab", "いいい"]]
+        expected = "あ  dd    ggg \nb   ええ  ¡¡ab\nc   ff    いいい"
+        adjoined = adj.adjoin(2, *data)
+        assert adjoined == expected