Upload folder using huggingface_hub (part 13)

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/style/test_highlight.py

@@ -0,0 +1,221 @@
+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
+    dtype = request.param[1]
+    item = np.nan if dtype == "float64" else NA
+    return DataFrame(
+        {"A": [0, item, 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(
+    "dtype",
+    [
+        int,
+        float,
+        "datetime64[ns]",
+        str,
+        "timedelta64[ns]",
+    ],
+)
+def test_all_highlight_dtypes(f, kwargs, dtype):
+    df = DataFrame([[0, 10], [20, 30]], dtype=dtype)
+    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

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/style/test_html.py

@@ -0,0 +1,1038 @@
+import pathlib
+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():
+    project_dir = pathlib.Path(__file__).parent.parent.parent.parent.parent.resolve()
+    template_dir = project_dir / "io" / "formats" / "templates"
+    loader = jinja2.FileSystemLoader(template_dir)
+    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 styler_multi():
+    df = DataFrame(
+        data=np.arange(16).reshape(4, 4),
+        columns=MultiIndex.from_product([["A", "B"], ["a", "b"]], names=["A&", "b&"]),
+        index=MultiIndex.from_product([["X", "Y"], ["x", "y"]], names=["X>", "y_"]),
+    )
+    return Styler(df)
+
+
+@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(datapath):
+    # make sure if templates are edited tests are updated as are setup fixtures
+    # to understand the dependency
+    path = datapath("..", "io", "formats", "templates", "html.tpl")
+    with open(path, 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:pass@web.com",
+            True,
+            "http://user:pass@web.com",
+        ),
+        (
+            "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")
+    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
+
+
+@pytest.mark.parametrize("escape_axis_0", [True, False])
+@pytest.mark.parametrize("escape_axis_1", [True, False])
+def test_format_index_names(styler_multi, escape_axis_0, escape_axis_1):
+    if escape_axis_0:
+        styler_multi.format_index_names(axis=0, escape="html")
+        expected_index = ["X&gt;", "y_"]
+    else:
+        expected_index = ["X>", "y_"]
+
+    if escape_axis_1:
+        styler_multi.format_index_names(axis=1, escape="html")
+        expected_columns = ["A&amp;", "b&amp;"]
+    else:
+        expected_columns = ["A&", "b&"]
+
+    result = styler_multi.to_html(table_uuid="test")
+    for expected_str in expected_index + expected_columns:
+        assert f"{expected_str}</th>" in result

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/style/test_matplotlib.py

@@ -0,0 +1,305 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    IndexSlice,
+    Series,
+)
+
+mpl = pytest.importorskip("matplotlib")
+pytest.importorskip("jinja2")
+
+from pandas.io.formats.style import Styler
+
+pytestmark = pytest.mark.usefixtures("mpl_cleanup")
+
+
+@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]]),  # reverse the index
+        (Series([2, 1], index=["B", "A"]), 1, [[1, 2], [1, 2]]),  # reverse 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("axis", [1, 0])
+def test_background_gradient_gmap_wrong_dataframe(styler_blank, axis):
+    # test giving a gmap in DataFrame but with wrong axis
+    gmap = DataFrame([[1, 2], [2, 1]], columns=["A", "B"], index=["X", "Y"])
+    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)

.venv/lib/python3.13/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}
+    """
+    )

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/style/test_style.py

@@ -0,0 +1,1602 @@
+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,
+        )
+    )
+    mi_styler.format_index_names(escape="html", axis=0)
+    mi_styler.format_index_names(escape="html", axis=1)
+    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_()
+        assert "mathjax_ignore" not in styler._repr_html_()
+
+        with option_context("styler.html.mathjax", False):
+            assert "tex2jax_ignore" in styler._repr_html_()
+            assert "mathjax_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
+
+        # issue #59623
+        expected = [("a", "b"), ("c", "url('data:123')")]
+        assert maybe_convert_css_to_tuples("a:b;c: url('data:123');") == expected
+
+        # if no value, return attr and empty string
+        expected = [("a", ""), ("c", "")]
+        assert maybe_convert_css_to_tuples("a:;c: ") == expected
+
+    def test_maybe_convert_css_to_tuples_err(self):
+        msg = (
+            "Styles supplied as string must follow CSS rule formats, "
+            "for example 'attr: val;'. 'err' was given."
+        )
+        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}"
+        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, temp_file):
+    # gh 47053
+    getattr(mi_styler, f"to_{format}")(temp_file)

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/style/test_to_latex.py

@@ -0,0 +1,1091 @@
+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(
+    "columns, expected",
+    [
+        (
+            None,
+            dedent(
+                """\
+            \\begin{tabular}{l}
+            \\end{tabular}
+            """
+            ),
+        ),
+        (
+            ["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(columns, expected: str, clines: str):
+    # GH 47203
+    df = DataFrame(columns=columns)
+    result = df.style.to_latex(clines=clines)
+    assert result == expected

.venv/lib/python3.13/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

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/style/test_to_typst.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_table(styler):
+    result = styler.to_typst()
+    expected = dedent(
+        """\
+    #table(
+      columns: 4,
+      [], [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_typst()
+    expected = dedent(
+        """\
+    #table(
+      columns: 4,
+      [], [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_typst()
+    expected = dedent(
+        """\
+    #table(
+      columns: 4,
+      [], [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_typst()
+    expected = dedent(
+        """\
+    #table(
+      columns: 4,
+      [], [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

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/style/test_tooltip.py

@@ -0,0 +1,179 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+)
+
+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(
+    "data, columns, index",
+    [
+        # Test basic reindex and ignoring blank
+        ([["Min", "Max"], [np.nan, ""]], ["A", "C"], ["x", "y"]),
+        # Test non-referenced columns, reversed col names, short index
+        ([["Max", "Min", "Bad-Col"]], ["C", "A", "D"], ["x"]),
+    ],
+)
+def test_tooltip_render(data, columns, index, styler):
+    ttips = DataFrame(data=data, columns=columns, index=index)
+
+    # 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
+    assert 'title="' 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
+
+
+@pytest.mark.parametrize(
+    "data, columns, index",
+    [
+        # Test basic reindex and ignoring blank
+        ([["Min", "Max"], [np.nan, ""]], ["A", "C"], ["x", "y"]),
+        # Test non-referenced columns, reversed col names, short index
+        ([["Max", "Min", "Bad-Col"]], ["C", "A", "D"], ["x"]),
+    ],
+)
+def test_tooltip_render_as_title(data, columns, index, styler):
+    ttips = DataFrame(data=data, columns=columns, index=index)
+    # GH 56605
+    result = styler.set_tooltips(ttips, as_title_attribute=True).to_html()
+
+    # test css not added
+    assert "#T_ .pd-t {\n  visibility: hidden;\n" not in result
+
+    # test 'Min' tooltip added as title attribute and css does not exist
+    assert "#T_ #T__row0_col0:hover .pd-t {\n  visibility: visible;\n}" not in result
+    assert '#T_ #T__row0_col0 .pd-t::after {\n  content: "Min";\n}' not in result
+    assert 'class="data row0 col0"  title="Min">0</td>' in result
+
+    # test 'Max' tooltip added as title attribute and css does not exist
+    assert "#T_ #T__row0_col2:hover .pd-t {\n  visibility: visible;\n}" not in result
+    assert '#T_ #T__row0_col2 .pd-t::after {\n  content: "Max";\n}' not in result
+    assert 'class="data row0 col2"  title="Max">2</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
+    assert 'class="data row0 col1" >1</td>' in result
+    assert 'class="data row1 col0" >3</td>' in result
+    assert 'class="data row1 col1" >4</td>' in result
+    assert 'class="data row1 col2" >5</td>' in result
+    assert 'class="data row2 col0" >6</td>' in result
+    assert 'class="data row2 col1" >7</td>' in result
+    assert 'class="data row2 col2" >8</td>' in result
+
+
+def test_tooltip_render_as_title_with_hidden_index_level():
+    df = DataFrame(
+        data=[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
+        columns=["A", "B", "C"],
+        index=MultiIndex.from_arrays(
+            [["x", "y", "z"], [1, 2, 3], ["aa", "bb", "cc"]],
+            names=["alpha", "num", "char"],
+        ),
+    )
+    ttips = DataFrame(
+        # Test basic reindex and ignoring blank, and hide level 2 (num) from index
+        data=[["Min", "Max"], [np.nan, ""]],
+        columns=["A", "C"],
+        index=MultiIndex.from_arrays(
+            [["x", "y"], [1, 2], ["aa", "bb"]], names=["alpha", "num", "char"]
+        ),
+    )
+    styler = Styler(df, uuid_len=0)
+    styler = styler.hide(axis=0, level=-1, names=True)
+    # GH 56605
+    result = styler.set_tooltips(ttips, as_title_attribute=True).to_html()
+
+    # test css not added
+    assert "#T_ .pd-t {\n  visibility: hidden;\n" not in result
+
+    # test 'Min' tooltip added as title attribute and css does not exist
+    assert "#T_ #T__row0_col0:hover .pd-t {\n  visibility: visible;\n}" not in result
+    assert '#T_ #T__row0_col0 .pd-t::after {\n  content: "Min";\n}' not in result
+    assert 'class="data row0 col0"  title="Min">0</td>' in result
+
+    # test 'Max' tooltip added as title attribute and css does not exist
+    assert "#T_ #T__row0_col2:hover .pd-t {\n  visibility: visible;\n}" not in result
+    assert '#T_ #T__row0_col2 .pd-t::after {\n  content: "Max";\n}' not in result
+    assert 'class="data row0 col2"  title="Max">2</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
+    assert 'class="data row0 col1" >1</td>' in result
+    assert 'class="data row1 col0" >3</td>' in result
+    assert 'class="data row1 col1" >4</td>' in result
+    assert 'class="data row1 col2" >5</td>' in result
+    assert 'class="data row2 col0" >6</td>' in result
+    assert 'class="data row2 col1" >7</td>' in result
+    assert 'class="data row2 col2" >8</td>' in result

.venv/lib/python3.13/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"

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_css.py

@@ -0,0 +1,288 @@
+import pytest
+
+from pandas.errors import CSSWarning
+
+import pandas._testing as tm
+
+from pandas.io.formats.css import CSSResolver
+
+
+def assert_resolves(css, props, inherited=None):
+    resolve = CSSResolver()
+    actual = resolve(css, inherited=inherited)
+    assert props == actual
+
+
+def assert_same_resolution(css1, css2, inherited=None):
+    resolve = CSSResolver()
+    resolved1 = resolve(css1, inherited=inherited)
+    resolved2 = resolve(css2, inherited=inherited)
+    assert resolved1 == resolved2
+
+
+@pytest.mark.parametrize(
+    "name,norm,abnorm",
+    [
+        (
+            "whitespace",
+            "hello: world; foo: bar",
+            " \t hello \t :\n  world \n  ;  \n foo: \tbar\n\n",
+        ),
+        ("case", "hello: world; foo: bar", "Hello: WORLD; foO: bar"),
+        ("empty-decl", "hello: world; foo: bar", "; hello: world;; foo: bar;\n; ;"),
+        ("empty-list", "", ";"),
+    ],
+)
+def test_css_parse_normalisation(name, norm, abnorm):
+    assert_same_resolution(norm, abnorm)
+
+
+@pytest.mark.parametrize(
+    "invalid_css,remainder,msg",
+    [
+        # No colon
+        ("hello-world", "", "expected a colon"),
+        ("border-style: solid; hello-world", "border-style: solid", "expected a colon"),
+        (
+            "border-style: solid; hello-world; font-weight: bold",
+            "border-style: solid; font-weight: bold",
+            "expected a colon",
+        ),
+        # Unclosed string fail
+        # Invalid size
+        ("font-size: blah", "font-size: 1em", "Unhandled size"),
+        ("font-size: 1a2b", "font-size: 1em", "Unhandled size"),
+        ("font-size: 1e5pt", "font-size: 1em", "Unhandled size"),
+        ("font-size: 1+6pt", "font-size: 1em", "Unhandled size"),
+        ("font-size: 1unknownunit", "font-size: 1em", "Unhandled size"),
+        ("font-size: 10", "font-size: 1em", "Unhandled size"),
+        ("font-size: 10 pt", "font-size: 1em", "Unhandled size"),
+        # Too many args
+        ("border-top: 1pt solid red green", "border-top: 1pt solid green", "Too many"),
+    ],
+)
+def test_css_parse_invalid(invalid_css, remainder, msg):
+    with tm.assert_produces_warning(CSSWarning, match=msg):
+        assert_same_resolution(invalid_css, remainder)
+
+
+@pytest.mark.parametrize(
+    "shorthand,expansions",
+    [
+        ("margin", ["margin-top", "margin-right", "margin-bottom", "margin-left"]),
+        ("padding", ["padding-top", "padding-right", "padding-bottom", "padding-left"]),
+        (
+            "border-width",
+            [
+                "border-top-width",
+                "border-right-width",
+                "border-bottom-width",
+                "border-left-width",
+            ],
+        ),
+        (
+            "border-color",
+            [
+                "border-top-color",
+                "border-right-color",
+                "border-bottom-color",
+                "border-left-color",
+            ],
+        ),
+        (
+            "border-style",
+            [
+                "border-top-style",
+                "border-right-style",
+                "border-bottom-style",
+                "border-left-style",
+            ],
+        ),
+    ],
+)
+def test_css_side_shorthands(shorthand, expansions):
+    top, right, bottom, left = expansions
+
+    assert_resolves(
+        f"{shorthand}: 1pt", {top: "1pt", right: "1pt", bottom: "1pt", left: "1pt"}
+    )
+
+    assert_resolves(
+        f"{shorthand}: 1pt 4pt", {top: "1pt", right: "4pt", bottom: "1pt", left: "4pt"}
+    )
+
+    assert_resolves(
+        f"{shorthand}: 1pt 4pt 2pt",
+        {top: "1pt", right: "4pt", bottom: "2pt", left: "4pt"},
+    )
+
+    assert_resolves(
+        f"{shorthand}: 1pt 4pt 2pt 0pt",
+        {top: "1pt", right: "4pt", bottom: "2pt", left: "0pt"},
+    )
+
+    with tm.assert_produces_warning(CSSWarning, match="Could not expand"):
+        assert_resolves(f"{shorthand}: 1pt 1pt 1pt 1pt 1pt", {})
+
+
+@pytest.mark.parametrize(
+    "shorthand,sides",
+    [
+        ("border-top", ["top"]),
+        ("border-right", ["right"]),
+        ("border-bottom", ["bottom"]),
+        ("border-left", ["left"]),
+        ("border", ["top", "right", "bottom", "left"]),
+    ],
+)
+def test_css_border_shorthand_sides(shorthand, sides):
+    def create_border_dict(sides, color=None, style=None, width=None):
+        resolved = {}
+        for side in sides:
+            if color:
+                resolved[f"border-{side}-color"] = color
+            if style:
+                resolved[f"border-{side}-style"] = style
+            if width:
+                resolved[f"border-{side}-width"] = width
+        return resolved
+
+    assert_resolves(
+        f"{shorthand}: 1pt red solid", create_border_dict(sides, "red", "solid", "1pt")
+    )
+
+
+@pytest.mark.parametrize(
+    "prop, expected",
+    [
+        ("1pt red solid", ("red", "solid", "1pt")),
+        ("red 1pt solid", ("red", "solid", "1pt")),
+        ("red solid 1pt", ("red", "solid", "1pt")),
+        ("solid 1pt red", ("red", "solid", "1pt")),
+        ("red solid", ("red", "solid", "1.500000pt")),
+        # Note: color=black is not CSS conforming
+        # (See https://drafts.csswg.org/css-backgrounds/#border-shorthands)
+        ("1pt solid", ("black", "solid", "1pt")),
+        ("1pt red", ("red", "none", "1pt")),
+        ("red", ("red", "none", "1.500000pt")),
+        ("1pt", ("black", "none", "1pt")),
+        ("solid", ("black", "solid", "1.500000pt")),
+        # Sizes
+        ("1em", ("black", "none", "12pt")),
+    ],
+)
+def test_css_border_shorthands(prop, expected):
+    color, style, width = expected
+
+    assert_resolves(
+        f"border-left: {prop}",
+        {
+            "border-left-color": color,
+            "border-left-style": style,
+            "border-left-width": width,
+        },
+    )
+
+
+@pytest.mark.parametrize(
+    "style,inherited,equiv",
+    [
+        ("margin: 1px; margin: 2px", "", "margin: 2px"),
+        ("margin: 1px", "margin: 2px", "margin: 1px"),
+        ("margin: 1px; margin: inherit", "margin: 2px", "margin: 2px"),
+        (
+            "margin: 1px; margin-top: 2px",
+            "",
+            "margin-left: 1px; margin-right: 1px; margin-bottom: 1px; margin-top: 2px",
+        ),
+        ("margin-top: 2px", "margin: 1px", "margin: 1px; margin-top: 2px"),
+        ("margin: 1px", "margin-top: 2px", "margin: 1px"),
+        (
+            "margin: 1px; margin-top: inherit",
+            "margin: 2px",
+            "margin: 1px; margin-top: 2px",
+        ),
+    ],
+)
+def test_css_precedence(style, inherited, equiv):
+    resolve = CSSResolver()
+    inherited_props = resolve(inherited)
+    style_props = resolve(style, inherited=inherited_props)
+    equiv_props = resolve(equiv)
+    assert style_props == equiv_props
+
+
+@pytest.mark.parametrize(
+    "style,equiv",
+    [
+        (
+            "margin: 1px; margin-top: inherit",
+            "margin-bottom: 1px; margin-right: 1px; margin-left: 1px",
+        ),
+        ("margin-top: inherit", ""),
+        ("margin-top: initial", ""),
+    ],
+)
+def test_css_none_absent(style, equiv):
+    assert_same_resolution(style, equiv)
+
+
+@pytest.mark.parametrize(
+    "size,resolved",
+    [
+        ("xx-small", "6pt"),
+        ("x-small", f"{7.5:f}pt"),
+        ("small", f"{9.6:f}pt"),
+        ("medium", "12pt"),
+        ("large", f"{13.5:f}pt"),
+        ("x-large", "18pt"),
+        ("xx-large", "24pt"),
+        ("8px", "6pt"),
+        ("1.25pc", "15pt"),
+        (".25in", "18pt"),
+        ("02.54cm", "72pt"),
+        ("25.4mm", "72pt"),
+        ("101.6q", "72pt"),
+    ],
+)
+@pytest.mark.parametrize("relative_to", [None, "16pt"])  # invariant to inherited size
+def test_css_absolute_font_size(size, relative_to, resolved):
+    if relative_to is None:
+        inherited = None
+    else:
+        inherited = {"font-size": relative_to}
+    assert_resolves(f"font-size: {size}", {"font-size": resolved}, inherited=inherited)
+
+
+@pytest.mark.parametrize(
+    "size,relative_to,resolved",
+    [
+        ("1em", None, "12pt"),
+        ("1.0em", None, "12pt"),
+        ("1.25em", None, "15pt"),
+        ("1em", "16pt", "16pt"),
+        ("1.0em", "16pt", "16pt"),
+        ("1.25em", "16pt", "20pt"),
+        ("1rem", "16pt", "12pt"),
+        ("1.0rem", "16pt", "12pt"),
+        ("1.25rem", "16pt", "15pt"),
+        ("100%", None, "12pt"),
+        ("125%", None, "15pt"),
+        ("100%", "16pt", "16pt"),
+        ("125%", "16pt", "20pt"),
+        ("2ex", None, "12pt"),
+        ("2.0ex", None, "12pt"),
+        ("2.50ex", None, "15pt"),
+        ("inherit", "16pt", "16pt"),
+        ("smaller", None, "10pt"),
+        ("smaller", "18pt", "15pt"),
+        ("larger", None, f"{14.4:f}pt"),
+        ("larger", "15pt", "18pt"),
+    ],
+)
+def test_css_relative_font_size(size, relative_to, resolved):
+    if relative_to is None:
+        inherited = None
+    else:
+        inherited = {"font-size": relative_to}
+    assert_resolves(f"font-size: {size}", {"font-size": resolved}, inherited=inherited)

.venv/lib/python3.13/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"

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_format.py

@@ -0,0 +1,2302 @@
+"""
+Tests for the file pandas.io.formats.format, *not* tests for general formatting
+of pandas objects.
+"""
+
+from datetime import datetime
+from io import StringIO
+import re
+from shutil import get_terminal_size
+
+import numpy as np
+import pytest
+
+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
+
+
+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_repr_truncation_dataframe_attrs(self):
+        # GH#60455
+        df = DataFrame([[0] * 10])
+        df.attrs["b"] = DataFrame([])
+        with option_context("display.max_columns", 2, "display.show_dimensions", False):
+            assert repr(df) == "   0  ...  9\n0  0  ...  0"
+
+    def test_repr_truncation_series_with_dataframe_attrs(self):
+        # GH#60568
+        ser = Series([0] * 10)
+        ser.attrs["b"] = DataFrame([])
+        with option_context("display.max_rows", 2, "display.show_dimensions", False):
+            assert repr(ser) == "0    0\n    ..\n9    0\ndtype: int64"
+
+    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_()
+
+    @pytest.mark.parametrize(
+        "data, format_option, expected_values",
+        [
+            (12345.6789, "{:12.3f}", "12345.679"),
+            (None, "{:.3f}", "None"),
+            ("", "{:.2f}", ""),
+            (112345.6789, "{:6.3f}", "112345.679"),
+            ("foo      foo", None, "foo&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;foo"),
+            (" foo", None, "foo"),
+            (
+                "foo foo       foo",
+                None,
+                "foo foo&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; foo",
+            ),  # odd no.of spaces
+            (
+                "foo foo    foo",
+                None,
+                "foo foo&nbsp;&nbsp;&nbsp;&nbsp;foo",
+            ),  # even no.of spaces
+        ],
+    )
+    def test_repr_float_formatting_html_output(
+        self, data, format_option, expected_values
+    ):
+        if format_option is not None:
+            with option_context("display.float_format", format_option.format):
+                df = DataFrame({"A": [data]})
+                html_output = df._repr_html_()
+                assert expected_values in html_output
+        else:
+            df = DataFrame({"A": [data]})
+            html_output = df._repr_html_()
+            assert expected_values in html_output
+
+    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
+
+    def test_east_asian_unicode_series(self, using_infer_string):
+        # 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",
+            ]
+        )
+        if using_infer_string:
+            expected = expected.replace("dtype: object", "dtype: str")
+        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",
+            ]
+        )
+        if using_infer_string:
+            expected = expected.replace("dtype: object", "dtype: str")
+        assert repr(s) == expected
+
+        # both
+        s = Series(
+            ["あ", "いい", "ううう", "ええええ"],
+            index=["ああ", "いいいい", "う", "えええ"],
+        )
+        expected = "".join(
+            [
+                "ああ         あ\n",
+                "いいいい      いい\n",
+                "う        ううう\n",
+                "えええ     ええええ\n",
+                "dtype: object",
+            ]
+        )
+        if using_infer_string:
+            expected = expected.replace("dtype: object", "dtype: str")
+        assert repr(s) == expected
+
+        # unicode footer
+        s = Series(
+            ["あ", "いい", "ううう", "ええええ"],
+            index=["ああ", "いいいい", "う", "えええ"],
+            name="おおおおおおお",
+        )
+        expected = (
+            "ああ         あ\nいいいい      いい\nう        ううう\n"
+            "えええ     ええええ\nName: おおおおおおお, dtype: object"
+        )
+        if using_infer_string:
+            expected = expected.replace("dtype: object", "dtype: str")
+        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"
+            )
+            if using_infer_string:
+                expected = expected.replace("dtype: object", "dtype: str")
+            assert repr(s) == expected
+
+            s.index = ["ああ", "いいいい", "う", "えええ"]
+            expected = (
+                "ああ        あ\n       ... \n"
+                "えええ    ええええ\n"
+                "Name: おおおおおおお, Length: 4, dtype: object"
+            )
+            if using_infer_string:
+                expected = expected.replace("dtype: object", "dtype: str")
+            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"
+            )
+            if using_infer_string:
+                expected = expected.replace("dtype: object", "dtype: str")
+            assert repr(s) == expected
+
+            # unicode values
+            s = Series(
+                ["あ", "いい", "ううう", "ええええ"],
+                index=["a", "bb", "c", "ddd"],
+            )
+            expected = (
+                "a            あ\nbb         いい\nc        ううう\n"
+                "ddd    ええええ\ndtype: object"
+            )
+            if using_infer_string:
+                expected = expected.replace("dtype: object", "dtype: str")
+            assert repr(s) == expected
+            # both
+            s = Series(
+                ["あ", "いい", "ううう", "ええええ"],
+                index=["ああ", "いいいい", "う", "えええ"],
+            )
+            expected = (
+                "ああ              あ\n"
+                "いいいい        いい\n"
+                "う            ううう\n"
+                "えええ      ええええ\ndtype: object"
+            )
+            if using_infer_string:
+                expected = expected.replace("dtype: object", "dtype: str")
+            assert repr(s) == expected
+
+            # unicode footer
+            s = Series(
+                ["あ", "いい", "ううう", "ええええ"],
+                index=["ああ", "いいいい", "う", "えええ"],
+                name="おおおおおおお",
+            )
+            expected = (
+                "ああ              あ\n"
+                "いいいい        いい\n"
+                "う            ううう\n"
+                "えええ      ええええ\n"
+                "Name: おおおおおおお, dtype: object"
+            )
+            if using_infer_string:
+                expected = expected.replace("dtype: object", "dtype: str")
+            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"
+                )
+                if using_infer_string:
+                    expected = expected.replace("dtype: object", "dtype: str")
+                assert repr(s) == expected
+
+                s.index = ["ああ", "いいいい", "う", "えええ"]
+                expected = (
+                    "ああ            あ\n"
+                    "            ...   \n"
+                    "えええ    ええええ\n"
+                    "Name: おおおおおおお, Length: 4, dtype: object"
+                )
+                if using_infer_string:
+                    expected = expected.replace("dtype: object", "dtype: str")
+                assert repr(s) == expected
+
+            # ambiguous unicode
+            s = Series(
+                ["¡¡", "い¡¡", "ううう", "ええええ"],
+                index=["ああ", "¡¡¡¡いい", "¡¡", "えええ"],
+            )
+            expected = (
+                "ああ              ¡¡\n"
+                "¡¡¡¡いい        い¡¡\n"
+                "¡¡            ううう\n"
+                "えええ      ええええ\ndtype: object"
+            )
+            if using_infer_string:
+                expected = expected.replace("dtype: object", "dtype: str")
+            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
+
+    def test_format_explicit(self, using_infer_string):
+        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"
+            if using_infer_string:
+                exp = exp.replace("dtype: object", "dtype: str")
+            assert exp == res
+            res = repr(test_sers["twol"])
+            exp = "0     ab\n1     ab\n      ..\n98    ab\n99    ab\ndtype: object"
+            if using_infer_string:
+                exp = exp.replace("dtype: object", "dtype: str")
+            assert exp == res
+            res = repr(test_sers["asc"])
+            exp = (
+                "0         a\n1        ab\n      ...  \n4     abcde\n5    "
+                "abcdef\ndtype: object"
+            )
+            if using_infer_string:
+                exp = exp.replace("dtype: object", "dtype: str")
+            assert exp == res
+            res = repr(test_sers["desc"])
+            exp = (
+                "5    abcdef\n4     abcde\n      ...  \n1        ab\n0         "
+                "a\ndtype: object"
+            )
+            if using_infer_string:
+                exp = exp.replace("dtype: object", "dtype: str")
+            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 _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")],
+)
+@pytest.mark.parametrize("filepath_or_buffer_id", ["string", "pathlike", "buffer"])
+def test_filepath_or_buffer_arg(
+    method,
+    tmp_path,
+    encoding,
+    data,
+    filepath_or_buffer_id,
+):
+    if filepath_or_buffer_id == "buffer":
+        filepath_or_buffer = StringIO()
+    elif filepath_or_buffer_id == "pathlike":
+        filepath_or_buffer = tmp_path / "foo"
+    else:
+        filepath_or_buffer = str(tmp_path / "foo")
+
+    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)
+        encoding = encoding or "utf-8"
+        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
+    if filepath_or_buffer_id == "buffer":
+        assert not filepath_or_buffer.closed
+
+
+@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())

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_ipython_compat.py

@@ -0,0 +1,91 @@
+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 cf.option_context("display.html.table_schema", True):
+                # Can't reuse opt on all systems GH#58055
+                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)

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_printing.py

@@ -0,0 +1,172 @@
+# Note! This file is aimed specifically at pandas.io.formats.printing utility
+# functions, not the general printing of pandas objects.
+from collections.abc import Mapping
+import string
+
+import pytest
+
+import pandas._config.config as cf
+
+import pandas as pd
+
+from pandas.io.formats import printing
+
+
+@pytest.mark.parametrize(
+    "input_names, expected_names",
+    [
+        (["'a b"], "['\\'a b']"),  # Escape leading quote
+        (["test's b"], "['test\\'s b']"),  # Escape apostrophe
+        (["'test' b"], "['\\'test\\' b']"),  # Escape surrounding quotes
+        (["test b'"], "['test b\\'']"),  # Escape single quote
+        (["test\n' b"], "['test\\n\\' b']"),  # Escape quotes, preserve newline
+    ],
+)
+def test_formatted_index_names(input_names, expected_names):
+    # GH#60190
+    df = pd.DataFrame({name: [1, 2, 3] for name in input_names}).set_index(input_names)
+    formatted_names = str(df.index.names)
+
+    assert formatted_names == expected_names
+
+
+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 MyMapping(Mapping):
+    def __getitem__(self, key):
+        return 4
+
+    def __iter__(self):
+        return iter(["a", "b"])
+
+    def __len__(self):
+        return 2
+
+
+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}"
+
+    def test_repr_dict(self):
+        assert printing.pprint_thing({"a": 4, "b": 4}) == "{'a': 4, 'b': 4}"
+
+    def test_repr_mapping(self):
+        assert printing.pprint_thing(MyMapping()) == "{'a': 4, 'b': 4}"
+
+    def test_repr_frozenset(self):
+        assert printing.pprint_thing(frozenset([1, 2])) == "frozenset({1, 2})"
+
+
+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

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_to_csv.py

@@ -0,0 +1,886 @@
+import io
+import os
+import sys
+from zipfile import ZipFile
+
+from _csv import Error
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    compat,
+)
+import pandas._testing as tm
+
+
+class TestToCSV:
+    def test_to_csv_with_single_column(self, temp_file):
+        # see gh-18676, https://bugs.python.org/issue32255
+        #
+        # Python's CSV library adds an extraneous '""'
+        # before the newline when the NaN-value is in
+        # the first row. Otherwise, only the newline
+        # character is added. This behavior is inconsistent
+        # and was patched in https://bugs.python.org/pull_request4672.
+        df1 = DataFrame([None, 1])
+        expected1 = """\
+""
+1.0
+"""
+        df1.to_csv(temp_file, header=None, index=None)
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected1
+
+        df2 = DataFrame([1, None])
+        expected2 = """\
+1.0
+""
+"""
+        df2.to_csv(temp_file, header=None, index=None)
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected2
+
+    def test_to_csv_default_encoding(self, temp_file):
+        # GH17097
+        df = DataFrame({"col": ["AAAAA", "ÄÄÄÄÄ", "ßßßßß", "聞聞聞聞聞"]})
+
+        # the default to_csv encoding is uft-8.
+        df.to_csv(temp_file)
+        tm.assert_frame_equal(pd.read_csv(temp_file, index_col=0), df)
+
+    def test_to_csv_quotechar(self, temp_file):
+        df = DataFrame({"col": [1, 2]})
+        expected = """\
+"","col"
+"0","1"
+"1","2"
+"""
+
+        df.to_csv(temp_file, quoting=1)  # 1=QUOTE_ALL
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected
+
+        expected = """\
+$$,$col$
+$0$,$1$
+$1$,$2$
+"""
+
+        df.to_csv(temp_file, quoting=1, quotechar="$")
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected
+
+        with pytest.raises(TypeError, match="quotechar"):
+            df.to_csv(temp_file, quoting=1, quotechar=None)
+
+    def test_to_csv_doublequote(self, temp_file):
+        df = DataFrame({"col": ['a"a', '"bb"']})
+        expected = '''\
+"","col"
+"0","a""a"
+"1","""bb"""
+'''
+
+        df.to_csv(temp_file, quoting=1, doublequote=True)  # QUOTE_ALL
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected
+
+        with pytest.raises(Error, match="escapechar"):
+            df.to_csv(temp_file, doublequote=False)  # no escapechar set
+
+    def test_to_csv_escapechar(self, temp_file):
+        df = DataFrame({"col": ['a"a', '"bb"']})
+        expected = """\
+"","col"
+"0","a\\"a"
+"1","\\"bb\\""
+"""
+
+        df.to_csv(temp_file, quoting=1, doublequote=False, escapechar="\\")
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected
+
+        df = DataFrame({"col": ["a,a", ",bb,"]})
+        expected = """\
+,col
+0,a\\,a
+1,\\,bb\\,
+"""
+
+        df.to_csv(temp_file, quoting=3, escapechar="\\")  # QUOTE_NONE
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected
+
+    def test_csv_to_string(self):
+        df = DataFrame({"col": [1, 2]})
+        expected_rows = [",col", "0,1", "1,2"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df.to_csv() == expected
+
+    def test_to_csv_decimal(self):
+        # see gh-781
+        df = DataFrame({"col1": [1], "col2": ["a"], "col3": [10.1]})
+
+        expected_rows = [",col1,col2,col3", "0,1,a,10.1"]
+        expected_default = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df.to_csv() == expected_default
+
+        expected_rows = [";col1;col2;col3", "0;1;a;10,1"]
+        expected_european_excel = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df.to_csv(decimal=",", sep=";") == expected_european_excel
+
+        expected_rows = [",col1,col2,col3", "0,1,a,10.10"]
+        expected_float_format_default = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df.to_csv(float_format="%.2f") == expected_float_format_default
+
+        expected_rows = [";col1;col2;col3", "0;1;a;10,10"]
+        expected_float_format = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert (
+            df.to_csv(decimal=",", sep=";", float_format="%.2f")
+            == expected_float_format
+        )
+
+        # see gh-11553: testing if decimal is taken into account for '0.0'
+        df = DataFrame({"a": [0, 1.1], "b": [2.2, 3.3], "c": 1})
+
+        expected_rows = ["a,b,c", "0^0,2^2,1", "1^1,3^3,1"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df.to_csv(index=False, decimal="^") == expected
+
+        # same but for an index
+        assert df.set_index("a").to_csv(decimal="^") == expected
+
+        # same for a multi-index
+        assert df.set_index(["a", "b"]).to_csv(decimal="^") == expected
+
+    def test_to_csv_float_format(self):
+        # testing if float_format is taken into account for the index
+        # GH 11553
+        df = DataFrame({"a": [0, 1], "b": [2.2, 3.3], "c": 1})
+
+        expected_rows = ["a,b,c", "0,2.20,1", "1,3.30,1"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df.set_index("a").to_csv(float_format="%.2f") == expected
+
+        # same for a multi-index
+        assert df.set_index(["a", "b"]).to_csv(float_format="%.2f") == expected
+
+    def test_to_csv_na_rep(self):
+        # see gh-11553
+        #
+        # Testing if NaN values are correctly represented in the index.
+        df = DataFrame({"a": [0, np.nan], "b": [0, 1], "c": [2, 3]})
+        expected_rows = ["a,b,c", "0.0,0,2", "_,1,3"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        assert df.set_index("a").to_csv(na_rep="_") == expected
+        assert df.set_index(["a", "b"]).to_csv(na_rep="_") == expected
+
+        # now with an index containing only NaNs
+        df = DataFrame({"a": np.nan, "b": [0, 1], "c": [2, 3]})
+        expected_rows = ["a,b,c", "_,0,2", "_,1,3"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        assert df.set_index("a").to_csv(na_rep="_") == expected
+        assert df.set_index(["a", "b"]).to_csv(na_rep="_") == expected
+
+        # check if na_rep parameter does not break anything when no NaN
+        df = DataFrame({"a": 0, "b": [0, 1], "c": [2, 3]})
+        expected_rows = ["a,b,c", "0,0,2", "0,1,3"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        assert df.set_index("a").to_csv(na_rep="_") == expected
+        assert df.set_index(["a", "b"]).to_csv(na_rep="_") == expected
+
+        csv = pd.Series(["a", pd.NA, "c"]).to_csv(na_rep="ZZZZZ")
+        expected = tm.convert_rows_list_to_csv_str([",0", "0,a", "1,ZZZZZ", "2,c"])
+        assert expected == csv
+
+    def test_to_csv_na_rep_nullable_string(self, nullable_string_dtype):
+        # GH 29975
+        # Make sure full na_rep shows up when a dtype is provided
+        expected = tm.convert_rows_list_to_csv_str([",0", "0,a", "1,ZZZZZ", "2,c"])
+        csv = pd.Series(["a", pd.NA, "c"], dtype=nullable_string_dtype).to_csv(
+            na_rep="ZZZZZ"
+        )
+        assert expected == csv
+
+    def test_to_csv_date_format(self):
+        # GH 10209
+        df_sec = DataFrame({"A": pd.date_range("20130101", periods=5, freq="s")})
+        df_day = DataFrame({"A": pd.date_range("20130101", periods=5, freq="D")})
+
+        expected_rows = [
+            ",A",
+            "0,2013-01-01 00:00:00",
+            "1,2013-01-01 00:00:01",
+            "2,2013-01-01 00:00:02",
+            "3,2013-01-01 00:00:03",
+            "4,2013-01-01 00:00:04",
+        ]
+        expected_default_sec = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df_sec.to_csv() == expected_default_sec
+
+        expected_rows = [
+            ",A",
+            "0,2013-01-01 00:00:00",
+            "1,2013-01-02 00:00:00",
+            "2,2013-01-03 00:00:00",
+            "3,2013-01-04 00:00:00",
+            "4,2013-01-05 00:00:00",
+        ]
+        expected_ymdhms_day = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df_day.to_csv(date_format="%Y-%m-%d %H:%M:%S") == expected_ymdhms_day
+
+        expected_rows = [
+            ",A",
+            "0,2013-01-01",
+            "1,2013-01-01",
+            "2,2013-01-01",
+            "3,2013-01-01",
+            "4,2013-01-01",
+        ]
+        expected_ymd_sec = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df_sec.to_csv(date_format="%Y-%m-%d") == expected_ymd_sec
+
+        expected_rows = [
+            ",A",
+            "0,2013-01-01",
+            "1,2013-01-02",
+            "2,2013-01-03",
+            "3,2013-01-04",
+            "4,2013-01-05",
+        ]
+        expected_default_day = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df_day.to_csv() == expected_default_day
+        assert df_day.to_csv(date_format="%Y-%m-%d") == expected_default_day
+
+        # see gh-7791
+        #
+        # Testing if date_format parameter is taken into account
+        # for multi-indexed DataFrames.
+        df_sec["B"] = 0
+        df_sec["C"] = 1
+
+        expected_rows = ["A,B,C", "2013-01-01,0,1.0"]
+        expected_ymd_sec = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        df_sec_grouped = df_sec.groupby([pd.Grouper(key="A", freq="1h"), "B"])
+        assert df_sec_grouped.mean().to_csv(date_format="%Y-%m-%d") == expected_ymd_sec
+
+    def test_to_csv_different_datetime_formats(self):
+        # GH#21734
+        df = DataFrame(
+            {
+                "date": pd.to_datetime("1970-01-01"),
+                "datetime": pd.date_range("1970-01-01", periods=2, freq="h"),
+            }
+        )
+        expected_rows = [
+            "date,datetime",
+            "1970-01-01,1970-01-01 00:00:00",
+            "1970-01-01,1970-01-01 01:00:00",
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df.to_csv(index=False) == expected
+
+    def test_to_csv_date_format_in_categorical(self):
+        # GH#40754
+        ser = pd.Series(pd.to_datetime(["2021-03-27", pd.NaT], format="%Y-%m-%d"))
+        ser = ser.astype("category")
+        expected = tm.convert_rows_list_to_csv_str(["0", "2021-03-27", '""'])
+        assert ser.to_csv(index=False) == expected
+
+        ser = pd.Series(
+            pd.date_range(
+                start="2021-03-27", freq="D", periods=1, tz="Europe/Berlin"
+            ).append(pd.DatetimeIndex([pd.NaT]))
+        )
+        ser = ser.astype("category")
+        assert ser.to_csv(index=False, date_format="%Y-%m-%d") == expected
+
+    def test_to_csv_float_ea_float_format(self):
+        # GH#45991
+        df = DataFrame({"a": [1.1, 2.02, pd.NA, 6.000006], "b": "c"})
+        df["a"] = df["a"].astype("Float64")
+        result = df.to_csv(index=False, float_format="%.5f")
+        expected = tm.convert_rows_list_to_csv_str(
+            ["a,b", "1.10000,c", "2.02000,c", ",c", "6.00001,c"]
+        )
+        assert result == expected
+
+    def test_to_csv_float_ea_no_float_format(self):
+        # GH#45991
+        df = DataFrame({"a": [1.1, 2.02, pd.NA, 6.000006], "b": "c"})
+        df["a"] = df["a"].astype("Float64")
+        result = df.to_csv(index=False)
+        expected = tm.convert_rows_list_to_csv_str(
+            ["a,b", "1.1,c", "2.02,c", ",c", "6.000006,c"]
+        )
+        assert result == expected
+
+    def test_to_csv_float_ea_nan_distinguish(self, using_nan_is_na):
+        # GH#61617, GH#65227 - to_csv should not crash when FloatingArray
+        # contains unmasked NaN (with distinguish_nan_and_na=True)
+        df = DataFrame({"a": pd.array([np.nan, pd.NA, 3.0], dtype="Float64"), "b": "c"})
+        result = df.to_csv(index=False)
+        if using_nan_is_na:
+            expected = tm.convert_rows_list_to_csv_str(["a,b", ",c", ",c", "3.0,c"])
+        else:
+            expected = tm.convert_rows_list_to_csv_str(["a,b", "nan,c", ",c", "3.0,c"])
+        assert result == expected
+
+    def test_to_csv_float_ea_nan_distinguish_series(self, using_nan_is_na):
+        # GH#65227 - Series.to_csv with FloatingArray containing both NaN and NA
+        ser = pd.Series((1, pd.NA, 0), index=["a", "b", "c"], dtype="Float64", name="x")
+        ser = ser / ser
+        result = ser.to_csv()
+        if using_nan_is_na:
+            expected = tm.convert_rows_list_to_csv_str([",x", "a,1.0", "b,", "c,"])
+        else:
+            expected = tm.convert_rows_list_to_csv_str([",x", "a,1.0", "b,", "c,nan"])
+        assert result == expected
+
+    def test_to_csv_multi_index(self):
+        # see gh-6618
+        df = DataFrame([1], columns=pd.MultiIndex.from_arrays([[1], [2]]))
+
+        exp_rows = [",1", ",2", "0,1"]
+        exp = tm.convert_rows_list_to_csv_str(exp_rows)
+        assert df.to_csv() == exp
+
+        exp_rows = ["1", "2", "1"]
+        exp = tm.convert_rows_list_to_csv_str(exp_rows)
+        assert df.to_csv(index=False) == exp
+
+        df = DataFrame(
+            [1],
+            columns=pd.MultiIndex.from_arrays([[1], [2]]),
+            index=pd.MultiIndex.from_arrays([[1], [2]]),
+        )
+
+        exp_rows = [",,1", ",,2", "1,2,1"]
+        exp = tm.convert_rows_list_to_csv_str(exp_rows)
+        assert df.to_csv() == exp
+
+        exp_rows = ["1", "2", "1"]
+        exp = tm.convert_rows_list_to_csv_str(exp_rows)
+        assert df.to_csv(index=False) == exp
+
+        df = DataFrame([1], columns=pd.MultiIndex.from_arrays([["foo"], ["bar"]]))
+
+        exp_rows = [",foo", ",bar", "0,1"]
+        exp = tm.convert_rows_list_to_csv_str(exp_rows)
+        assert df.to_csv() == exp
+
+        exp_rows = ["foo", "bar", "1"]
+        exp = tm.convert_rows_list_to_csv_str(exp_rows)
+        assert df.to_csv(index=False) == exp
+
+    @pytest.mark.parametrize(
+        "ind,expected",
+        [
+            (
+                pd.MultiIndex(levels=[[1.0]], codes=[[0]], names=["x"]),
+                "x,data\n1.0,1\n",
+            ),
+            (
+                pd.MultiIndex(
+                    levels=[[1.0], [2.0]], codes=[[0], [0]], names=["x", "y"]
+                ),
+                "x,y,data\n1.0,2.0,1\n",
+            ),
+        ],
+    )
+    def test_to_csv_single_level_multi_index(self, ind, expected, frame_or_series):
+        # see gh-19589
+        obj = frame_or_series(pd.Series([1], ind, name="data"))
+
+        result = obj.to_csv(lineterminator="\n", header=True)
+        assert result == expected
+
+    def test_to_csv_string_array_ascii(self, temp_file):
+        # GH 10813
+        str_array = [{"names": ["foo", "bar"]}, {"names": ["baz", "qux"]}]
+        df = DataFrame(str_array)
+        expected_ascii = """\
+,names
+0,"['foo', 'bar']"
+1,"['baz', 'qux']"
+"""
+        df.to_csv(temp_file, encoding="ascii")
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected_ascii
+
+    def test_to_csv_string_array_utf8(self, temp_file):
+        # GH 10813
+        str_array = [{"names": ["foo", "bar"]}, {"names": ["baz", "qux"]}]
+        df = DataFrame(str_array)
+        expected_utf8 = """\
+,names
+0,"['foo', 'bar']"
+1,"['baz', 'qux']"
+"""
+        df.to_csv(temp_file, encoding="utf-8")
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected_utf8
+
+    def test_to_csv_string_with_lf(self, temp_file):
+        # GH 20353
+        data = {"int": [1, 2, 3], "str_lf": ["abc", "d\nef", "g\nh\n\ni"]}
+        df = DataFrame(data)
+
+        # case 1: The default line terminator(=os.linesep)(PR 21406)
+        os_linesep = os.linesep.encode("utf-8")
+        expected_noarg = (
+            b"int,str_lf"
+            + os_linesep
+            + b"1,abc"
+            + os_linesep
+            + b'2,"d\nef"'
+            + os_linesep
+            + b'3,"g\nh\n\ni"'
+            + os_linesep
+        )
+        df.to_csv(temp_file, index=False)
+        with open(temp_file, "rb") as f:
+            assert f.read() == expected_noarg
+
+        # case 2: LF as line terminator
+        expected_lf = b'int,str_lf\n1,abc\n2,"d\nef"\n3,"g\nh\n\ni"\n'
+        df.to_csv(temp_file, lineterminator="\n", index=False)
+        with open(temp_file, "rb") as f:
+            assert f.read() == expected_lf
+
+        # case 3: CRLF as line terminator
+        # 'lineterminator' should not change inner element
+        expected_crlf = b'int,str_lf\r\n1,abc\r\n2,"d\nef"\r\n3,"g\nh\n\ni"\r\n'
+        df.to_csv(temp_file, lineterminator="\r\n", index=False)
+        with open(temp_file, "rb") as f:
+            assert f.read() == expected_crlf
+
+    def test_to_csv_string_with_crlf(self, temp_file):
+        # GH 20353
+        data = {"int": [1, 2, 3], "str_crlf": ["abc", "d\r\nef", "g\r\nh\r\n\r\ni"]}
+        df = DataFrame(data)
+        # case 1: The default line terminator(=os.linesep)(PR 21406)
+        os_linesep = os.linesep.encode("utf-8")
+        expected_noarg = (
+            b"int,str_crlf"
+            + os_linesep
+            + b"1,abc"
+            + os_linesep
+            + b'2,"d\r\nef"'
+            + os_linesep
+            + b'3,"g\r\nh\r\n\r\ni"'
+            + os_linesep
+        )
+        df.to_csv(temp_file, index=False)
+        with open(temp_file, "rb") as f:
+            assert f.read() == expected_noarg
+
+        # case 2: LF as line terminator
+        expected_lf = b'int,str_crlf\n1,abc\n2,"d\r\nef"\n3,"g\r\nh\r\n\r\ni"\n'
+        df.to_csv(temp_file, lineterminator="\n", index=False)
+        with open(temp_file, "rb") as f:
+            assert f.read() == expected_lf
+
+        # case 3: CRLF as line terminator
+        # 'lineterminator' should not change inner element
+        expected_crlf = (
+            b'int,str_crlf\r\n1,abc\r\n2,"d\r\nef"\r\n3,"g\r\nh\r\n\r\ni"\r\n'
+        )
+        df.to_csv(temp_file, lineterminator="\r\n", index=False)
+        with open(temp_file, "rb") as f:
+            assert f.read() == expected_crlf
+
+    def test_to_csv_stdout_file(self, capsys):
+        # GH 21561
+        df = DataFrame([["foo", "bar"], ["baz", "qux"]], columns=["name_1", "name_2"])
+        expected_rows = [",name_1,name_2", "0,foo,bar", "1,baz,qux"]
+        expected_ascii = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        df.to_csv(sys.stdout, encoding="ascii")
+        captured = capsys.readouterr()
+
+        assert captured.out == expected_ascii
+        assert not sys.stdout.closed
+
+    @pytest.mark.xfail(
+        compat.is_platform_windows(),
+        reason=(
+            "Especially in Windows, file stream should not be passed"
+            "to csv writer without newline='' option."
+            "(https://docs.python.org/3/library/csv.html#csv.writer)"
+        ),
+    )
+    def test_to_csv_write_to_open_file(self, temp_file):
+        # GH 21696
+        df = DataFrame({"a": ["x", "y", "z"]})
+        expected = """\
+manual header
+x
+y
+z
+"""
+        with open(temp_file, "w", encoding="utf-8") as f:
+            f.write("manual header\n")
+            df.to_csv(f, header=None, index=None)
+        with open(temp_file, encoding="utf-8") as f:
+            assert f.read() == expected
+
+    def test_to_csv_write_to_open_file_with_newline_py3(self, temp_file):
+        # see gh-21696
+        # see gh-20353
+        df = DataFrame({"a": ["x", "y", "z"]})
+        expected_rows = ["x", "y", "z"]
+        expected = "manual header\n" + tm.convert_rows_list_to_csv_str(expected_rows)
+
+        with open(temp_file, "w", newline="", encoding="utf-8") as f:
+            f.write("manual header\n")
+            df.to_csv(f, header=None, index=None)
+
+        with open(temp_file, "rb") as f:
+            assert f.read() == bytes(expected, "utf-8")
+
+    @pytest.mark.parametrize("to_infer", [True, False])
+    @pytest.mark.parametrize("read_infer", [True, False])
+    def test_to_csv_compression(
+        self,
+        compression_only,
+        read_infer,
+        to_infer,
+        compression_to_extension,
+        temp_file,
+    ):
+        # see gh-15008
+        compression = compression_only
+
+        df = DataFrame({"A": [1]})
+
+        to_compression = "infer" if to_infer else compression
+        read_compression = "infer" if read_infer else compression
+
+        path_ext = str(temp_file) + "." + compression_to_extension[compression]
+        df.to_csv(path_ext, compression=to_compression)
+        result = pd.read_csv(path_ext, index_col=0, compression=read_compression)
+        tm.assert_frame_equal(result, df)
+
+    def test_to_csv_compression_dict(self, compression_only, temp_file):
+        # GH 26023
+        method = compression_only
+        df = DataFrame({"ABC": [1]})
+        extension = {
+            "gzip": "gz",
+            "zstd": "zst",
+        }.get(method, method)
+
+        path = str(temp_file) + "." + extension
+        df.to_csv(path, compression={"method": method})
+        read_df = pd.read_csv(path, index_col=0)
+        tm.assert_frame_equal(read_df, df)
+
+    def test_to_csv_compression_dict_no_method_raises(self, temp_file):
+        # GH 26023
+        df = DataFrame({"ABC": [1]})
+        compression = {"some_option": True}
+        msg = "must have key 'method'"
+
+        with pytest.raises(ValueError, match=msg):
+            df.to_csv(temp_file, compression=compression)
+
+    @pytest.mark.parametrize("compression", ["zip", "infer"])
+    @pytest.mark.parametrize("archive_name", ["test_to_csv.csv", "test_to_csv.zip"])
+    def test_to_csv_zip_arguments(self, compression, archive_name, temp_file):
+        # GH 26023
+        df = DataFrame({"ABC": [1]})
+
+        path = str(temp_file) + ".zip"
+        df.to_csv(
+            path, compression={"method": compression, "archive_name": archive_name}
+        )
+        with ZipFile(path) as zp:
+            assert len(zp.filelist) == 1
+            archived_file = zp.filelist[0].filename
+            assert archived_file == archive_name
+
+    @pytest.mark.parametrize(
+        "filename,expected_arcname",
+        [
+            ("archive.csv", "archive.csv"),
+            ("archive.tsv", "archive.tsv"),
+            ("archive.csv.zip", "archive.csv"),
+            ("archive.tsv.zip", "archive.tsv"),
+            ("archive.zip", "archive"),
+        ],
+    )
+    def test_to_csv_zip_infer_name(self, tmp_path, filename, expected_arcname):
+        # GH 39465
+        df = DataFrame({"ABC": [1]})
+        path = tmp_path / filename
+        df.to_csv(path, compression="zip")
+        with ZipFile(path) as zp:
+            assert len(zp.filelist) == 1
+            archived_file = zp.filelist[0].filename
+            assert archived_file == expected_arcname
+
+    @pytest.mark.parametrize("df_new_type", ["Int64"])
+    def test_to_csv_na_rep_long_string(self, df_new_type):
+        # see gh-25099
+        df = DataFrame({"c": [pd.NA] * 3})
+        df = df.astype(df_new_type)
+        expected_rows = ["c", "mynull", "mynull", "mynull"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        result = df.to_csv(index=False, na_rep="mynull", encoding="ascii")
+
+        assert expected == result
+
+    def test_to_csv_timedelta_precision(self):
+        # GH 6783
+        s = pd.Series([1, 1]).astype("timedelta64[ns]")
+        buf = io.StringIO()
+        s.to_csv(buf)
+        result = buf.getvalue()
+        expected_rows = [
+            ",0",
+            "0,0 days 00:00:00.000000001",
+            "1,0 days 00:00:00.000000001",
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_na_rep_truncated(self):
+        # https://github.com/pandas-dev/pandas/issues/31447
+        result = pd.Series(range(8, 12)).to_csv(na_rep="-")
+        expected = tm.convert_rows_list_to_csv_str([",0", "0,8", "1,9", "2,10", "3,11"])
+        assert result == expected
+
+        result = pd.Series([True, False]).to_csv(na_rep="nan")
+        expected = tm.convert_rows_list_to_csv_str([",0", "0,True", "1,False"])
+        assert result == expected
+
+        result = pd.Series([1.1, 2.2]).to_csv(na_rep=".")
+        expected = tm.convert_rows_list_to_csv_str([",0", "0,1.1", "1,2.2"])
+        assert result == expected
+
+    @pytest.mark.parametrize("errors", ["surrogatepass", "ignore", "replace"])
+    def test_to_csv_errors(self, errors, temp_file):
+        # GH 22610
+        data = ["\ud800foo"]
+        ser = pd.Series(data, index=Index(data, dtype=object), dtype=object)
+
+        ser.to_csv(temp_file, errors=errors)
+        # No use in reading back the data as it is not the same anymore
+        # due to the error handling
+
+    @pytest.mark.parametrize("mode", ["wb", "w"])
+    def test_to_csv_binary_handle(self, mode, temp_file):
+        """
+        Binary file objects should work (if 'mode' contains a 'b') or even without
+        it in most cases.
+
+        GH 35058 and GH 19827
+        """
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD")),
+            index=Index([f"i-{i}" for i in range(30)]),
+        )
+
+        with open(temp_file, mode="w+b") as handle:
+            df.to_csv(handle, mode=mode)
+        tm.assert_frame_equal(df, pd.read_csv(temp_file, index_col=0))
+
+    @pytest.mark.parametrize("mode", ["wb", "w"])
+    def test_to_csv_encoding_binary_handle(self, mode, temp_file):
+        """
+        Binary file objects should honor a specified encoding.
+
+        GH 23854 and GH 13068 with binary handles
+        """
+        # example from GH 23854
+        content = "a, b, 🐟".encode("utf-8-sig")
+        buffer = io.BytesIO(content)
+        df = pd.read_csv(buffer, encoding="utf-8-sig")
+
+        buffer = io.BytesIO()
+        df.to_csv(buffer, mode=mode, encoding="utf-8-sig", index=False)
+        buffer.seek(0)  # tests whether file handle wasn't closed
+        assert buffer.getvalue().startswith(content)
+
+        # example from GH 13068
+        with open(temp_file, "w+b") as handle:
+            DataFrame().to_csv(handle, mode=mode, encoding="utf-8-sig")
+
+            handle.seek(0)
+            assert handle.read().startswith(b'\xef\xbb\xbf""')
+
+
+def test_to_csv_iterative_compression_name(compression, temp_file):
+    # GH 38714
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD")),
+        index=Index([f"i-{i}" for i in range(30)]),
+    )
+    df.to_csv(temp_file, compression=compression, chunksize=1)
+    tm.assert_frame_equal(
+        pd.read_csv(temp_file, compression=compression, index_col=0), df
+    )
+
+
+def test_to_csv_iterative_compression_buffer(compression):
+    # GH 38714
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD")),
+        index=Index([f"i-{i}" for i in range(30)]),
+    )
+    with io.BytesIO() as buffer:
+        df.to_csv(buffer, compression=compression, chunksize=1)
+        buffer.seek(0)
+        tm.assert_frame_equal(
+            pd.read_csv(buffer, compression=compression, index_col=0), df
+        )
+        assert not buffer.closed
+
+
+def test_new_style_float_format_basic():
+    df = DataFrame({"A": [1234.56789, 9876.54321]})
+    result = df.to_csv(float_format="{:.2f}", lineterminator="\n")
+    expected = ",A\n0,1234.57\n1,9876.54\n"
+    assert result == expected
+
+
+def test_new_style_float_format_thousands():
+    df = DataFrame({"A": [1234.56789, 9876.54321]})
+    result = df.to_csv(float_format="{:,.2f}", lineterminator="\n")
+    expected = ',A\n0,"1,234.57"\n1,"9,876.54"\n'
+    assert result == expected
+
+
+def test_new_style_scientific_format():
+    df = DataFrame({"A": [0.000123, 0.000456]})
+    result = df.to_csv(float_format="{:.2e}", lineterminator="\n")
+    expected = ",A\n0,1.23e-04\n1,4.56e-04\n"
+    assert result == expected
+
+
+def test_new_style_with_nan():
+    df = DataFrame({"A": [1.23, np.nan, 4.56]})
+    result = df.to_csv(float_format="{:.2f}", na_rep="NA", lineterminator="\n")
+    expected = ",A\n0,1.23\n1,NA\n2,4.56\n"
+    assert result == expected
+
+
+def test_new_style_with_mixed_types():
+    df = DataFrame({"A": [1.23, 4.56], "B": ["x", "y"]})
+    result = df.to_csv(float_format="{:.2f}", lineterminator="\n")
+    expected = ",A,B\n0,1.23,x\n1,4.56,y\n"
+    assert result == expected
+
+
+def test_new_style_with_mixed_types_in_column():
+    df = DataFrame({"A": [1.23, "text", 4.56]})
+    result = df.to_csv(float_format="{:.2f}", lineterminator="\n")
+    expected = ",A\n0,1.23\n1,text\n2,4.56\n"
+    assert result == expected
+
+
+def test_invalid_new_style_format_missing_brace():
+    df = DataFrame({"A": [1.23]})
+    with pytest.raises(ValueError, match="Invalid new-style format string '{:.2f"):
+        df.to_csv(float_format="{:.2f")
+
+
+def test_invalid_new_style_format_specifier():
+    df = DataFrame({"A": [1.23]})
+    with pytest.raises(ValueError, match="Invalid new-style format string '{:.2z}'"):
+        df.to_csv(float_format="{:.2z}")
+
+
+def test_old_style_format_compatibility():
+    df = DataFrame({"A": [1234.56789, 9876.54321]})
+    result = df.to_csv(float_format="%.2f", lineterminator="\n")
+    expected = ",A\n0,1234.57\n1,9876.54\n"
+    assert result == expected
+
+
+def test_callable_float_format_compatibility():
+    df = DataFrame({"A": [1234.56789, 9876.54321]})
+    result = df.to_csv(float_format=lambda x: f"{x:,.2f}", lineterminator="\n")
+    expected = ',A\n0,"1,234.57"\n1,"9,876.54"\n'
+    assert result == expected
+
+
+def test_no_float_format():
+    df = DataFrame({"A": [1.23, 4.56]})
+    result = df.to_csv(float_format=None, lineterminator="\n")
+    expected = ",A\n0,1.23\n1,4.56\n"
+    assert result == expected
+
+
+def test_large_numbers():
+    df = DataFrame({"A": [1e308, 2e308]})
+    result = df.to_csv(float_format="{:.2e}", lineterminator="\n")
+    expected = ",A\n0,1.00e+308\n1,inf\n"
+    assert result == expected
+
+
+def test_zero_and_negative():
+    df = DataFrame({"A": [0.0, -1.23456]})
+    result = df.to_csv(float_format="{:+.2f}", lineterminator="\n")
+    expected = ",A\n0,+0.00\n1,-1.23\n"
+    assert result == expected
+
+
+def test_unicode_format():
+    df = DataFrame({"A": [1.23, 4.56]})
+    result = df.to_csv(float_format="{:.2f}€", encoding="utf-8", lineterminator="\n")
+    expected = ",A\n0,1.23€\n1,4.56€\n"
+    assert result == expected
+
+
+def test_empty_dataframe():
+    df = DataFrame({"A": []})
+    result = df.to_csv(float_format="{:.2f}", lineterminator="\n")
+    expected = ",A\n"
+    assert result == expected
+
+
+def test_multi_column_float():
+    df = DataFrame({"A": [1.23, 4.56], "B": [7.89, 0.12]})
+    result = df.to_csv(float_format="{:.2f}", lineterminator="\n")
+    expected = ",A,B\n0,1.23,7.89\n1,4.56,0.12\n"
+    assert result == expected
+
+
+def test_invalid_float_format_type():
+    df = DataFrame({"A": [1.23]})
+    with pytest.raises(ValueError, match="float_format must be a string or callable"):
+        df.to_csv(float_format=123)
+
+
+def test_new_style_with_inf():
+    df = DataFrame({"A": [1.23, np.inf, -np.inf]})
+    result = df.to_csv(float_format="{:.2f}", na_rep="NA", lineterminator="\n")
+    expected = ",A\n0,1.23\n1,inf\n2,-inf\n"
+    assert result == expected
+
+
+def test_new_style_with_precision_edge():
+    df = DataFrame({"A": [1.23456789]})
+    result = df.to_csv(float_format="{:.10f}", lineterminator="\n")
+    expected = ",A\n0,1.2345678900\n"
+    assert result == expected
+
+
+def test_new_style_with_template():
+    df = DataFrame({"A": [1234.56789]})
+    result = df.to_csv(float_format="Value: {:,.2f}", lineterminator="\n")
+    expected = ',A\n0,"Value: 1,234.57"\n'
+    assert result == expected

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_to_excel.py

@@ -0,0 +1,473 @@
+"""Tests formatting as writer-agnostic ExcelCells
+
+ExcelFormatter is tested implicitly in pandas/tests/io/excel
+"""
+
+import string
+
+import pytest
+
+from pandas.errors import CSSWarning
+
+import pandas._testing as tm
+
+from pandas.io.formats.excel import (
+    CssExcelCell,
+    CSSToExcelConverter,
+)
+
+
+@pytest.mark.parametrize(
+    "css,expected",
+    [
+        # FONT
+        # - name
+        ("font-family: foo,bar", {"font": {"name": "foo"}}),
+        ('font-family: "foo bar",baz', {"font": {"name": "foo bar"}}),
+        ("font-family: foo,\nbar", {"font": {"name": "foo"}}),
+        ("font-family: foo, bar,    baz", {"font": {"name": "foo"}}),
+        ("font-family: bar, foo", {"font": {"name": "bar"}}),
+        ("font-family: 'foo bar', baz", {"font": {"name": "foo bar"}}),
+        ("font-family: 'foo \\'bar', baz", {"font": {"name": "foo 'bar"}}),
+        ('font-family: "foo \\"bar", baz', {"font": {"name": 'foo "bar'}}),
+        ('font-family: "foo ,bar", baz', {"font": {"name": "foo ,bar"}}),
+        # - family
+        ("font-family: serif", {"font": {"name": "serif", "family": 1}}),
+        ("font-family: Serif", {"font": {"name": "serif", "family": 1}}),
+        ("font-family: roman, serif", {"font": {"name": "roman", "family": 1}}),
+        ("font-family: roman, sans-serif", {"font": {"name": "roman", "family": 2}}),
+        ("font-family: roman, sans serif", {"font": {"name": "roman"}}),
+        ("font-family: roman, sansserif", {"font": {"name": "roman"}}),
+        ("font-family: roman, cursive", {"font": {"name": "roman", "family": 4}}),
+        ("font-family: roman, fantasy", {"font": {"name": "roman", "family": 5}}),
+        # - size
+        ("font-size: 1em", {"font": {"size": 12}}),
+        ("font-size: xx-small", {"font": {"size": 6}}),
+        ("font-size: x-small", {"font": {"size": 7.5}}),
+        ("font-size: small", {"font": {"size": 9.6}}),
+        ("font-size: medium", {"font": {"size": 12}}),
+        ("font-size: large", {"font": {"size": 13.5}}),
+        ("font-size: x-large", {"font": {"size": 18}}),
+        ("font-size: xx-large", {"font": {"size": 24}}),
+        ("font-size: 50%", {"font": {"size": 6}}),
+        # - bold
+        ("font-weight: 100", {"font": {"bold": False}}),
+        ("font-weight: 200", {"font": {"bold": False}}),
+        ("font-weight: 300", {"font": {"bold": False}}),
+        ("font-weight: 400", {"font": {"bold": False}}),
+        ("font-weight: normal", {"font": {"bold": False}}),
+        ("font-weight: lighter", {"font": {"bold": False}}),
+        ("font-weight: bold", {"font": {"bold": True}}),
+        ("font-weight: bolder", {"font": {"bold": True}}),
+        ("font-weight: 700", {"font": {"bold": True}}),
+        ("font-weight: 800", {"font": {"bold": True}}),
+        ("font-weight: 900", {"font": {"bold": True}}),
+        # - italic
+        ("font-style: italic", {"font": {"italic": True}}),
+        ("font-style: oblique", {"font": {"italic": True}}),
+        # - underline
+        ("text-decoration: underline", {"font": {"underline": "single"}}),
+        ("text-decoration: overline", {}),
+        ("text-decoration: none", {}),
+        # - strike
+        ("text-decoration: line-through", {"font": {"strike": True}}),
+        (
+            "text-decoration: underline line-through",
+            {"font": {"strike": True, "underline": "single"}},
+        ),
+        (
+            "text-decoration: underline; text-decoration: line-through",
+            {"font": {"strike": True}},
+        ),
+        # - color
+        ("color: red", {"font": {"color": "FF0000"}}),
+        ("color: #ff0000", {"font": {"color": "FF0000"}}),
+        ("color: #f0a", {"font": {"color": "FF00AA"}}),
+        # - shadow
+        ("text-shadow: none", {"font": {"shadow": False}}),
+        ("text-shadow: 0px -0em 0px #CCC", {"font": {"shadow": False}}),
+        ("text-shadow: 0px -0em 0px #999", {"font": {"shadow": False}}),
+        ("text-shadow: 0px -0em 0px", {"font": {"shadow": False}}),
+        ("text-shadow: 2px -0em 0px #CCC", {"font": {"shadow": True}}),
+        ("text-shadow: 0px -2em 0px #CCC", {"font": {"shadow": True}}),
+        ("text-shadow: 0px -0em 2px #CCC", {"font": {"shadow": True}}),
+        ("text-shadow: 0px -0em 2px", {"font": {"shadow": True}}),
+        ("text-shadow: 0px -2em", {"font": {"shadow": True}}),
+        # FILL
+        # - color, fillType
+        (
+            "background-color: red",
+            {"fill": {"fgColor": "FF0000", "patternType": "solid"}},
+        ),
+        (
+            "background-color: #ff0000",
+            {"fill": {"fgColor": "FF0000", "patternType": "solid"}},
+        ),
+        (
+            "background-color: #f0a",
+            {"fill": {"fgColor": "FF00AA", "patternType": "solid"}},
+        ),
+        # BORDER
+        # - style
+        (
+            "border-style: solid",
+            {
+                "border": {
+                    "top": {"style": "medium"},
+                    "bottom": {"style": "medium"},
+                    "left": {"style": "medium"},
+                    "right": {"style": "medium"},
+                }
+            },
+        ),
+        (
+            "border-style: solid; border-width: thin",
+            {
+                "border": {
+                    "top": {"style": "thin"},
+                    "bottom": {"style": "thin"},
+                    "left": {"style": "thin"},
+                    "right": {"style": "thin"},
+                }
+            },
+        ),
+        (
+            "border-top-style: solid; border-top-width: thin",
+            {"border": {"top": {"style": "thin"}}},
+        ),
+        (
+            "border-top-style: solid; border-top-width: 1pt",
+            {"border": {"top": {"style": "thin"}}},
+        ),
+        ("border-top-style: solid", {"border": {"top": {"style": "medium"}}}),
+        (
+            "border-top-style: solid; border-top-width: medium",
+            {"border": {"top": {"style": "medium"}}},
+        ),
+        (
+            "border-top-style: solid; border-top-width: 2pt",
+            {"border": {"top": {"style": "medium"}}},
+        ),
+        (
+            "border-top-style: solid; border-top-width: thick",
+            {"border": {"top": {"style": "thick"}}},
+        ),
+        (
+            "border-top-style: solid; border-top-width: 4pt",
+            {"border": {"top": {"style": "thick"}}},
+        ),
+        (
+            "border-top-style: solid; border-top-width: none",
+            {"border": {"top": {"style": "none"}}},
+        ),
+        (
+            "border-top-style: solid; border-top-width: 0.000001pt",
+            {"border": {"top": {"style": "none"}}},
+        ),
+        (
+            "border-top-style: dotted",
+            {"border": {"top": {"style": "mediumDashDotDot"}}},
+        ),
+        (
+            "border-top-style: dotted; border-top-width: thin",
+            {"border": {"top": {"style": "dotted"}}},
+        ),
+        ("border-top-style: dashed", {"border": {"top": {"style": "mediumDashed"}}}),
+        (
+            "border-top-style: dashed; border-top-width: thin",
+            {"border": {"top": {"style": "dashed"}}},
+        ),
+        ("border-top-style: double", {"border": {"top": {"style": "double"}}}),
+        # - color
+        (
+            "border-style: solid; border-color: #0000ff",
+            {
+                "border": {
+                    "top": {"style": "medium", "color": "0000FF"},
+                    "right": {"style": "medium", "color": "0000FF"},
+                    "bottom": {"style": "medium", "color": "0000FF"},
+                    "left": {"style": "medium", "color": "0000FF"},
+                }
+            },
+        ),
+        (
+            "border-top-style: double; border-top-color: blue",
+            {"border": {"top": {"style": "double", "color": "0000FF"}}},
+        ),
+        (
+            "border-top-style: solid; border-top-color: #06c",
+            {"border": {"top": {"style": "medium", "color": "0066CC"}}},
+        ),
+        (
+            "border-top-color: blue",
+            {"border": {"top": {"color": "0000FF", "style": "none"}}},
+        ),
+        (
+            "border-top-style: slantDashDot; border-top-color: blue",
+            {"border": {"top": {"style": "slantDashDot", "color": "0000FF"}}},
+        ),
+        # ALIGNMENT
+        # - horizontal
+        ("text-align: center", {"alignment": {"horizontal": "center"}}),
+        ("text-align: left", {"alignment": {"horizontal": "left"}}),
+        ("text-align: right", {"alignment": {"horizontal": "right"}}),
+        ("text-align: justify", {"alignment": {"horizontal": "justify"}}),
+        # - vertical
+        ("vertical-align: top", {"alignment": {"vertical": "top"}}),
+        ("vertical-align: text-top", {"alignment": {"vertical": "top"}}),
+        ("vertical-align: middle", {"alignment": {"vertical": "center"}}),
+        ("vertical-align: bottom", {"alignment": {"vertical": "bottom"}}),
+        ("vertical-align: text-bottom", {"alignment": {"vertical": "bottom"}}),
+        # - wrap_text
+        ("white-space: nowrap", {"alignment": {"wrap_text": False}}),
+        ("white-space: pre", {"alignment": {"wrap_text": False}}),
+        ("white-space: pre-line", {"alignment": {"wrap_text": False}}),
+        ("white-space: normal", {"alignment": {"wrap_text": True}}),
+        # NUMBER FORMAT
+        ("number-format: 0%", {"number_format": {"format_code": "0%"}}),
+        (
+            "number-format: 0§[Red](0)§-§@;",
+            {"number_format": {"format_code": "0;[red](0);-;@"}},  # GH 46152
+        ),
+    ],
+)
+def test_css_to_excel(css, expected):
+    convert = CSSToExcelConverter()
+    assert expected == convert(css)
+
+
+def test_css_to_excel_multiple():
+    convert = CSSToExcelConverter()
+    actual = convert(
+        """
+        font-weight: bold;
+        text-decoration: underline;
+        color: red;
+        border-width: thin;
+        text-align: center;
+        vertical-align: top;
+        unused: something;
+    """
+    )
+    assert {
+        "font": {"bold": True, "underline": "single", "color": "FF0000"},
+        "border": {
+            "top": {"style": "thin"},
+            "right": {"style": "thin"},
+            "bottom": {"style": "thin"},
+            "left": {"style": "thin"},
+        },
+        "alignment": {"horizontal": "center", "vertical": "top"},
+    } == actual
+
+
+@pytest.mark.parametrize(
+    "css",
+    [
+        "border-top-style: unhandled-border-style",
+        "border-style: another-unhandled-style",
+    ],
+)
+def test_css_to_excel_unhandled_border_style_warns(css):
+    """Test that unhandled border styles raise a CSSWarning."""
+    convert = CSSToExcelConverter()
+    with tm.assert_produces_warning(CSSWarning, match="Unhandled border style format"):
+        convert(css)
+
+
+@pytest.mark.parametrize(
+    "css,inherited,expected",
+    [
+        ("font-weight: bold", "", {"font": {"bold": True}}),
+        ("", "font-weight: bold", {"font": {"bold": True}}),
+        (
+            "font-weight: bold",
+            "font-style: italic",
+            {"font": {"bold": True, "italic": True}},
+        ),
+        ("font-style: normal", "font-style: italic", {"font": {"italic": False}}),
+        ("font-style: inherit", "", {}),
+        (
+            "font-style: normal; font-style: inherit",
+            "font-style: italic",
+            {"font": {"italic": True}},
+        ),
+    ],
+)
+def test_css_to_excel_inherited(css, inherited, expected):
+    convert = CSSToExcelConverter(inherited)
+    assert expected == convert(css)
+
+
+@pytest.mark.parametrize(
+    "input_color,output_color",
+    (
+        list(CSSToExcelConverter.NAMED_COLORS.items())
+        + [("#" + rgb, rgb) for rgb in CSSToExcelConverter.NAMED_COLORS.values()]
+        + [("#F0F", "FF00FF"), ("#ABC", "AABBCC")]
+    ),
+)
+def test_css_to_excel_good_colors(input_color, output_color):
+    # see gh-18392
+    css = (
+        f"border-top-color: {input_color}; "
+        f"border-right-color: {input_color}; "
+        f"border-bottom-color: {input_color}; "
+        f"border-left-color: {input_color}; "
+        f"background-color: {input_color}; "
+        f"color: {input_color}"
+    )
+
+    expected = {}
+
+    expected["fill"] = {"patternType": "solid", "fgColor": output_color}
+
+    expected["font"] = {"color": output_color}
+
+    expected["border"] = {
+        k: {"color": output_color, "style": "none"}
+        for k in ("top", "right", "bottom", "left")
+    }
+
+    with tm.assert_produces_warning(None):
+        convert = CSSToExcelConverter()
+        assert expected == convert(css)
+
+
+@pytest.mark.parametrize("input_color", [None, "not-a-color"])
+def test_css_to_excel_bad_colors(input_color):
+    # see gh-18392
+    css = (
+        f"border-top-color: {input_color}; "
+        f"border-right-color: {input_color}; "
+        f"border-bottom-color: {input_color}; "
+        f"border-left-color: {input_color}; "
+        f"background-color: {input_color}; "
+        f"color: {input_color}"
+    )
+
+    expected = {}
+
+    if input_color is not None:
+        expected["fill"] = {"patternType": "solid"}
+
+    with tm.assert_produces_warning(CSSWarning, match="Unhandled color format"):
+        convert = CSSToExcelConverter()
+        assert expected == convert(css)
+
+
+@pytest.mark.parametrize("input_color", ["#", "#1234567"])
+def test_css_to_excel_invalid_color_raises(input_color):
+    """Test that invalid colors raise a ValueError."""
+    css = (
+        f"border-top-color: {input_color}; "
+        f"border-right-color: {input_color}; "
+        f"border-bottom-color: {input_color}; "
+        f"border-left-color: {input_color}; "
+        f"background-color: {input_color}; "
+        f"color: {input_color}"
+    )
+
+    convert = CSSToExcelConverter()
+    with pytest.raises(ValueError, match=f"Unexpected color {input_color}"):
+        convert(css)
+
+
+def tests_css_named_colors_valid():
+    upper_hexs = set(map(str.upper, string.hexdigits))
+    for color in CSSToExcelConverter.NAMED_COLORS.values():
+        assert len(color) == 6 and all(c in upper_hexs for c in color)
+
+
+def test_css_named_colors_from_mpl_present():
+    mpl_colors = pytest.importorskip("matplotlib.colors")
+
+    pd_colors = CSSToExcelConverter.NAMED_COLORS
+    for name, color in mpl_colors.CSS4_COLORS.items():
+        assert name in pd_colors and pd_colors[name] == color[1:]
+
+
+@pytest.mark.parametrize(
+    "styles,expected",
+    [
+        ([("color", "green"), ("color", "red")], "color: red;"),
+        ([("font-weight", "bold"), ("font-weight", "normal")], "font-weight: normal;"),
+        ([("text-align", "center"), ("TEXT-ALIGN", "right")], "text-align: right;"),
+    ],
+)
+def test_css_excel_cell_precedence(styles, expected):
+    """It applies favors latter declarations over former declarations"""
+    # See GH 47371
+    converter = CSSToExcelConverter()
+    converter._call_cached.cache_clear()
+    css_styles = {(0, 0): styles}
+    cell = CssExcelCell(
+        row=0,
+        col=0,
+        val="",
+        style=None,
+        css_styles=css_styles,
+        css_row=0,
+        css_col=0,
+        css_converter=converter,
+    )
+    converter._call_cached.cache_clear()
+
+    assert cell.style == converter(expected)
+
+
+@pytest.mark.parametrize(
+    "styles,cache_hits,cache_misses",
+    [
+        ([[("color", "green"), ("color", "red"), ("color", "green")]], 0, 1),
+        (
+            [
+                [("font-weight", "bold")],
+                [("font-weight", "normal"), ("font-weight", "bold")],
+            ],
+            1,
+            1,
+        ),
+        ([[("text-align", "center")], [("TEXT-ALIGN", "center")]], 1, 1),
+        (
+            [
+                [("font-weight", "bold"), ("text-align", "center")],
+                [("font-weight", "bold"), ("text-align", "left")],
+            ],
+            0,
+            2,
+        ),
+        (
+            [
+                [("font-weight", "bold"), ("text-align", "center")],
+                [("font-weight", "bold"), ("text-align", "left")],
+                [("font-weight", "bold"), ("text-align", "center")],
+            ],
+            1,
+            2,
+        ),
+    ],
+)
+def test_css_excel_cell_cache(styles, cache_hits, cache_misses):
+    """It caches unique cell styles"""
+    # See GH 47371
+    converter = CSSToExcelConverter()
+    converter._call_cached.cache_clear()
+
+    css_styles = {(0, i): _style for i, _style in enumerate(styles)}
+    for css_row, css_col in css_styles:
+        CssExcelCell(
+            row=0,
+            col=0,
+            val="",
+            style=None,
+            css_styles=css_styles,
+            css_row=css_row,
+            css_col=css_col,
+            css_converter=converter,
+        )
+    cache_info = converter._call_cached.cache_info()
+    converter._call_cached.cache_clear()
+
+    assert cache_info.hits == cache_hits
+    assert cache_info.misses == cache_misses

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_to_html.py

@@ -0,0 +1,1166 @@
+from datetime import datetime
+from io import StringIO
+import itertools
+import re
+import textwrap
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    get_option,
+    option_context,
+)
+
+import pandas.io.formats.format as fmt
+
+lorem_ipsum = (
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod "
+    "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim "
+    "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex "
+    "ea commodo consequat. Duis aute irure dolor in reprehenderit in "
+    "voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur "
+    "sint occaecat cupidatat non proident, sunt in culpa qui officia "
+    "deserunt mollit anim id est laborum."
+)
+
+
+def expected_html(datapath, name):
+    """
+    Read HTML file from formats data directory.
+
+    Parameters
+    ----------
+    datapath : pytest fixture
+        The datapath fixture injected into a test by pytest.
+    name : str
+        The name of the HTML file without the suffix.
+
+    Returns
+    -------
+    str : contents of HTML file.
+    """
+    filename = ".".join([name, "html"])
+    filepath = datapath("io", "formats", "data", "html", filename)
+    with open(filepath, encoding="utf-8") as f:
+        html = f.read()
+    return html.rstrip()
+
+
+@pytest.fixture(params=["mixed", "empty"])
+def biggie_df_fixture(request):
+    """Fixture for a big mixed Dataframe and an empty Dataframe"""
+    if request.param == "mixed":
+        df = DataFrame(
+            {
+                "A": np.random.default_rng(2).standard_normal(200),
+                "B": Index([f"{i}?!" for i in range(200)]),
+            },
+            index=np.arange(200),
+        )
+        df.loc[:20, "A"] = np.nan
+        df.loc[:20, "B"] = np.nan
+        return df
+    elif request.param == "empty":
+        df = DataFrame(index=np.arange(200))
+        return df
+
+
+@pytest.fixture(params=fmt.VALID_JUSTIFY_PARAMETERS)
+def justify(request):
+    return request.param
+
+
+@pytest.mark.parametrize("col_space", [30, 50])
+def test_to_html_with_col_space(col_space):
+    df = DataFrame(np.random.default_rng(2).random(size=(1, 3)))
+    # check that col_space affects HTML generation
+    # and be very brittle about it.
+    result = df.to_html(col_space=col_space)
+    hdrs = [x for x in result.split(r"\n") if re.search(r"<th[>\s]", x)]
+    assert len(hdrs) > 0
+    for h in hdrs:
+        assert "min-width" in h
+        assert str(col_space) in h
+
+
+def test_to_html_with_column_specific_col_space_raises():
+    df = DataFrame(
+        np.random.default_rng(2).random(size=(3, 3)), columns=["a", "b", "c"]
+    )
+
+    msg = (
+        "Col_space length\\(\\d+\\) should match DataFrame number of columns\\(\\d+\\)"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.to_html(col_space=[30, 40])
+
+    with pytest.raises(ValueError, match=msg):
+        df.to_html(col_space=[30, 40, 50, 60])
+
+    msg = "unknown column"
+    with pytest.raises(ValueError, match=msg):
+        df.to_html(col_space={"a": "foo", "b": 23, "d": 34})
+
+
+def test_to_html_with_column_specific_col_space():
+    df = DataFrame(
+        np.random.default_rng(2).random(size=(3, 3)), columns=["a", "b", "c"]
+    )
+
+    result = df.to_html(col_space={"a": "2em", "b": 23})
+    hdrs = [x for x in result.split("\n") if re.search(r"<th[>\s]", x)]
+    assert 'min-width: 2em;">a</th>' in hdrs[1]
+    assert 'min-width: 23px;">b</th>' in hdrs[2]
+    assert "<th>c</th>" in hdrs[3]
+
+    result = df.to_html(col_space=["1em", 2, 3])
+    hdrs = [x for x in result.split("\n") if re.search(r"<th[>\s]", x)]
+    assert 'min-width: 1em;">a</th>' in hdrs[1]
+    assert 'min-width: 2px;">b</th>' in hdrs[2]
+    assert 'min-width: 3px;">c</th>' in hdrs[3]
+
+
+def test_to_html_with_empty_string_label():
+    # GH 3547, to_html regards empty string labels as repeated labels
+    data = {"c1": ["a", "b"], "c2": ["a", ""], "data": [1, 2]}
+    df = DataFrame(data).set_index(["c1", "c2"])
+    result = df.to_html()
+    assert "rowspan" not in result
+
+
+@pytest.mark.parametrize(
+    "df_data,expected",
+    [
+        ({"\u03c3": np.arange(10.0)}, "unicode_1"),
+        ({"A": ["\u03c3"]}, "unicode_2"),
+    ],
+)
+def test_to_html_unicode(df_data, expected, datapath):
+    df = DataFrame(df_data)
+    expected = expected_html(datapath, expected)
+    result = df.to_html()
+    assert result == expected
+
+
+def test_to_html_encoding(float_frame, temp_file):
+    # GH 28663
+    float_frame.to_html(temp_file, encoding="gbk")
+    expected = temp_file.read_text(encoding="gbk")
+    assert float_frame.to_html() == expected
+
+
+def test_to_html_decimal(datapath):
+    # GH 12031
+    df = DataFrame({"A": [6.0, 3.1, 2.2]})
+    result = df.to_html(decimal=",")
+    expected = expected_html(datapath, "gh12031_expected_output")
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "kwargs,string,expected",
+    [
+        ({}, "<type 'str'>", "escaped"),
+        ({"escape": False}, "<b>bold</b>", "escape_disabled"),
+    ],
+)
+def test_to_html_escaped(kwargs, string, expected, datapath):
+    a = "str<ing1 &amp;"
+    b = "stri>ng2 &amp;"
+
+    test_dict = {"co<l1": {a: string, b: string}, "co>l2": {a: string, b: string}}
+    result = DataFrame(test_dict).to_html(**kwargs)
+    expected = expected_html(datapath, expected)
+    assert result == expected
+
+
+@pytest.mark.parametrize("index_is_named", [True, False])
+def test_to_html_multiindex_index_false(index_is_named, datapath):
+    # GH 8452
+    df = DataFrame(
+        {"a": range(2), "b": range(3, 5), "c": range(5, 7), "d": range(3, 5)}
+    )
+    df.columns = MultiIndex.from_product([["a", "b"], ["c", "d"]])
+    if index_is_named:
+        df.index = Index(df.index.values, name="idx")
+    result = df.to_html(index=False)
+    expected = expected_html(datapath, "gh8452_expected_output")
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "multi_sparse,expected",
+    [
+        (False, "multiindex_sparsify_false_multi_sparse_1"),
+        (False, "multiindex_sparsify_false_multi_sparse_2"),
+        (True, "multiindex_sparsify_1"),
+        (True, "multiindex_sparsify_2"),
+    ],
+)
+def test_to_html_multiindex_sparsify(multi_sparse, expected, datapath):
+    index = MultiIndex.from_arrays([[0, 0, 1, 1], [0, 1, 0, 1]], names=["foo", None])
+    df = DataFrame([[0, 1], [2, 3], [4, 5], [6, 7]], index=index)
+    if expected.endswith("2"):
+        df.columns = index[::2]
+    with option_context("display.multi_sparse", multi_sparse):
+        result = df.to_html()
+    expected = expected_html(datapath, expected)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "max_rows,expected",
+    [
+        (60, "gh14882_expected_output_1"),
+        # Test that ... appears in a middle level
+        (56, "gh14882_expected_output_2"),
+    ],
+)
+def test_to_html_multiindex_odd_even_truncate(max_rows, expected, datapath):
+    # GH 14882 - Issue on truncation with odd length DataFrame
+    index = MultiIndex.from_product(
+        [[100, 200, 300], [10, 20, 30], [1, 2, 3, 4, 5, 6, 7]], names=["a", "b", "c"]
+    )
+    df = DataFrame({"n": range(len(index))}, index=index)
+    result = df.to_html(max_rows=max_rows)
+    expected = expected_html(datapath, expected)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "df,formatters,expected",
+    [
+        (
+            DataFrame(
+                [[0, 1], [2, 3], [4, 5], [6, 7]],
+                columns=Index(["foo", None], dtype=object),
+                index=np.arange(4),
+            ),
+            {"__index__": lambda x: "abcd"[x]},
+            "index_formatter",
+        ),
+        (
+            DataFrame({"months": [datetime(2016, 1, 1), datetime(2016, 2, 2)]}),
+            {"months": lambda x: x.strftime("%Y-%m")},
+            "datetime64_monthformatter",
+        ),
+        (
+            DataFrame(
+                {
+                    "hod": pd.to_datetime(
+                        ["10:10:10.100", "12:12:12.120"], format="%H:%M:%S.%f"
+                    )
+                }
+            ),
+            {"hod": lambda x: x.strftime("%H:%M")},
+            "datetime64_hourformatter",
+        ),
+        (
+            DataFrame(
+                {
+                    "i": pd.Series([1, 2], dtype="int64"),
+                    "f": pd.Series([1, 2], dtype="float64"),
+                    "I": pd.Series([1, 2], dtype="Int64"),
+                    "s": pd.Series([1, 2], dtype="string"),
+                    "b": pd.Series([True, False], dtype="boolean"),
+                    "c": pd.Series(["a", "b"], dtype=pd.CategoricalDtype(["a", "b"])),
+                    "o": pd.Series([1, "2"], dtype=object),
+                }
+            ),
+            [lambda x: "formatted"] * 7,
+            "various_dtypes_formatted",
+        ),
+    ],
+)
+def test_to_html_formatters(df, formatters, expected, datapath):
+    expected = expected_html(datapath, expected)
+    result = df.to_html(formatters=formatters)
+    assert result == expected
+
+
+def test_to_html_regression_GH6098():
+    df = DataFrame(
+        {
+            "clé1": ["a", "a", "b", "b", "a"],
+            "clé2": ["1er", "2ème", "1er", "2ème", "1er"],
+            "données1": np.random.default_rng(2).standard_normal(5),
+            "données2": np.random.default_rng(2).standard_normal(5),
+        }
+    )
+
+    # it works
+    df.pivot_table(index=["clé1"], columns=["clé2"])._repr_html_()
+
+
+def test_to_html_truncate(datapath):
+    index = pd.date_range(start="20010101", freq="D", periods=20)
+    df = DataFrame(index=index, columns=range(20))
+    result = df.to_html(max_rows=8, max_cols=4)
+    expected = expected_html(datapath, "truncate")
+    assert result == expected
+
+
+@pytest.mark.parametrize("size", [1, 5])
+def test_html_invalid_formatters_arg_raises(size):
+    # issue-28469
+    df = DataFrame(columns=["a", "b", "c"])
+    msg = "Formatters length({}) should match DataFrame number of columns(3)"
+    with pytest.raises(ValueError, match=re.escape(msg.format(size))):
+        df.to_html(formatters=["{}".format] * size)
+
+
+def test_to_html_truncate_formatter(datapath):
+    # issue-25955
+    data = [
+        {"A": 1, "B": 2, "C": 3, "D": 4},
+        {"A": 5, "B": 6, "C": 7, "D": 8},
+        {"A": 9, "B": 10, "C": 11, "D": 12},
+        {"A": 13, "B": 14, "C": 15, "D": 16},
+    ]
+
+    df = DataFrame(data)
+    fmt = lambda x: str(x) + "_mod"
+    formatters = [fmt, fmt, None, None]
+    result = df.to_html(formatters=formatters, max_cols=3)
+    expected = expected_html(datapath, "truncate_formatter")
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "sparsify,expected",
+    [(True, "truncate_multi_index"), (False, "truncate_multi_index_sparse_off")],
+)
+def test_to_html_truncate_multi_index(sparsify, expected, datapath):
+    arrays = [
+        ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+        ["one", "two", "one", "two", "one", "two", "one", "two"],
+    ]
+    df = DataFrame(index=arrays, columns=arrays)
+    result = df.to_html(max_rows=7, max_cols=7, sparsify=sparsify)
+    expected = expected_html(datapath, expected)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "option,result,expected",
+    [
+        (None, lambda df: df.to_html(), "1"),
+        (None, lambda df: df.to_html(border=2), "2"),
+        (2, lambda df: df.to_html(), "2"),
+        (2, lambda df: df._repr_html_(), "2"),
+    ],
+)
+def test_to_html_border(option, result, expected):
+    df = DataFrame({"A": [1, 2]})
+    if option is None:
+        result = result(df)
+    else:
+        with option_context("display.html.border", option):
+            result = result(df)
+    expected = f'border="{expected}"'
+    assert expected in result
+
+
+@pytest.mark.parametrize("biggie_df_fixture", ["mixed"], indirect=True)
+def test_to_html(biggie_df_fixture):
+    # TODO: split this test
+    df = biggie_df_fixture
+    s = df.to_html()
+
+    buf = StringIO()
+    retval = df.to_html(buf=buf)
+    assert retval is None
+    assert buf.getvalue() == s
+
+    assert isinstance(s, str)
+
+    df.to_html(columns=["B", "A"], col_space=17)
+    df.to_html(columns=["B", "A"], formatters={"A": lambda x: f"{x:.1f}"})
+
+    df.to_html(columns=["B", "A"], float_format=str)
+    df.to_html(columns=["B", "A"], col_space=12, float_format=str)
+
+
+@pytest.mark.parametrize("biggie_df_fixture", ["empty"], indirect=True)
+def test_to_html_empty_dataframe(biggie_df_fixture):
+    df = biggie_df_fixture
+    df.to_html()
+
+
+def test_to_html_filename(biggie_df_fixture, tmpdir):
+    df = biggie_df_fixture
+    expected = df.to_html()
+    path = tmpdir.join("test.html")
+    df.to_html(path)
+    result = path.read()
+    assert result == expected
+
+
+def test_to_html_with_no_bold():
+    df = DataFrame({"x": np.random.default_rng(2).standard_normal(5)})
+    html = df.to_html(bold_rows=False)
+    result = html[html.find("</thead>")]
+    assert "<strong" not in result
+
+
+def test_to_html_columns_arg(float_frame):
+    result = float_frame.to_html(columns=["A"])
+    assert "<th>B</th>" not in result
+
+
+@pytest.mark.parametrize(
+    "columns,justify,expected",
+    [
+        (
+            MultiIndex.from_arrays(
+                [np.arange(2).repeat(2), np.mod(range(4), 2)],
+                names=["CL0", "CL1"],
+            ),
+            "left",
+            "multiindex_1",
+        ),
+        (
+            MultiIndex.from_arrays([np.arange(4), np.mod(range(4), 2)]),
+            "right",
+            "multiindex_2",
+        ),
+    ],
+)
+def test_to_html_multiindex(columns, justify, expected, datapath):
+    df = DataFrame([list("abcd"), list("efgh")], columns=columns)
+    result = df.to_html(justify=justify)
+    expected = expected_html(datapath, expected)
+    assert result == expected
+
+
+def test_to_html_justify(justify, datapath):
+    df = DataFrame(
+        {"A": [6, 30000, 2], "B": [1, 2, 70000], "C": [223442, 0, 1]},
+        columns=["A", "B", "C"],
+    )
+    result = df.to_html(justify=justify)
+    expected = expected_html(datapath, "justify").format(justify=justify)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "justify", ["super-right", "small-left", "noinherit", "tiny", "pandas"]
+)
+def test_to_html_invalid_justify(justify):
+    # GH 17527
+    df = DataFrame()
+    msg = "Invalid value for justify parameter"
+
+    with pytest.raises(ValueError, match=msg):
+        df.to_html(justify=justify)
+
+
+class TestHTMLIndex:
+    @pytest.fixture
+    def df(self):
+        index = ["foo", "bar", "baz"]
+        df = DataFrame(
+            {"A": [1, 2, 3], "B": [1.2, 3.4, 5.6], "C": ["one", "two", np.nan]},
+            columns=["A", "B", "C"],
+            index=index,
+        )
+        return df
+
+    @pytest.fixture
+    def expected_without_index(self, datapath):
+        return expected_html(datapath, "index_2")
+
+    def test_to_html_flat_index_without_name(
+        self, datapath, df, expected_without_index
+    ):
+        expected_with_index = expected_html(datapath, "index_1")
+        assert df.to_html() == expected_with_index
+
+        result = df.to_html(index=False)
+        for i in df.index:
+            assert i not in result
+        assert result == expected_without_index
+
+    def test_to_html_flat_index_with_name(self, datapath, df, expected_without_index):
+        df.index = Index(["foo", "bar", "baz"], name="idx")
+        expected_with_index = expected_html(datapath, "index_3")
+        assert df.to_html() == expected_with_index
+        assert df.to_html(index=False) == expected_without_index
+
+    def test_to_html_multiindex_without_names(
+        self, datapath, df, expected_without_index
+    ):
+        tuples = [("foo", "car"), ("foo", "bike"), ("bar", "car")]
+        df.index = MultiIndex.from_tuples(tuples)
+
+        expected_with_index = expected_html(datapath, "index_4")
+        assert df.to_html() == expected_with_index
+
+        result = df.to_html(index=False)
+        for i in ["foo", "bar", "car", "bike"]:
+            assert i not in result
+        # must be the same result as normal index
+        assert result == expected_without_index
+
+    def test_to_html_multiindex_with_names(self, datapath, df, expected_without_index):
+        tuples = [("foo", "car"), ("foo", "bike"), ("bar", "car")]
+        df.index = MultiIndex.from_tuples(tuples, names=["idx1", "idx2"])
+        expected_with_index = expected_html(datapath, "index_5")
+        assert df.to_html() == expected_with_index
+        assert df.to_html(index=False) == expected_without_index
+
+
+@pytest.mark.parametrize("classes", ["sortable draggable", ["sortable", "draggable"]])
+def test_to_html_with_classes(classes, datapath):
+    df = DataFrame()
+    expected = expected_html(datapath, "with_classes")
+    result = df.to_html(classes=classes)
+    assert result == expected
+
+
+def test_to_html_no_index_max_rows(datapath):
+    # GH 14998
+    df = DataFrame({"A": [1, 2, 3, 4]})
+    result = df.to_html(index=False, max_rows=1)
+    expected = expected_html(datapath, "gh14998_expected_output")
+    assert result == expected
+
+
+def test_to_html_multiindex_max_cols(datapath):
+    # GH 6131
+    index = MultiIndex(
+        levels=[["ba", "bb", "bc"], ["ca", "cb", "cc"]],
+        codes=[[0, 1, 2], [0, 1, 2]],
+        names=["b", "c"],
+    )
+    columns = MultiIndex(
+        levels=[["d"], ["aa", "ab", "ac"]],
+        codes=[[0, 0, 0], [0, 1, 2]],
+        names=[None, "a"],
+    )
+    data = np.array(
+        [[1.0, np.nan, np.nan], [np.nan, 2.0, np.nan], [np.nan, np.nan, 3.0]]
+    )
+    df = DataFrame(data, index, columns)
+    result = df.to_html(max_cols=2)
+    expected = expected_html(datapath, "gh6131_expected_output")
+    assert result == expected
+
+
+def test_to_html_multi_indexes_index_false(datapath):
+    # GH 22579
+    df = DataFrame(
+        {"a": range(10), "b": range(10, 20), "c": range(10, 20), "d": range(10, 20)}
+    )
+    df.columns = MultiIndex.from_product([["a", "b"], ["c", "d"]])
+    df.index = MultiIndex.from_product([["a", "b"], ["c", "d", "e", "f", "g"]])
+    result = df.to_html(index=False)
+    expected = expected_html(datapath, "gh22579_expected_output")
+    assert result == expected
+
+
+@pytest.mark.parametrize("index_names", [True, False])
+@pytest.mark.parametrize("header", [True, False])
+@pytest.mark.parametrize("index", [True, False])
+@pytest.mark.parametrize(
+    "column_index, column_type",
+    [
+        (Index([0, 1]), "unnamed_standard"),
+        (Index([0, 1], name="columns.name"), "named_standard"),
+        (MultiIndex.from_product([["a"], ["b", "c"]]), "unnamed_multi"),
+        (
+            MultiIndex.from_product(
+                [["a"], ["b", "c"]], names=["columns.name.0", "columns.name.1"]
+            ),
+            "named_multi",
+        ),
+    ],
+)
+@pytest.mark.parametrize(
+    "row_index, row_type",
+    [
+        (Index([0, 1]), "unnamed_standard"),
+        (Index([0, 1], name="index.name"), "named_standard"),
+        (MultiIndex.from_product([["a"], ["b", "c"]]), "unnamed_multi"),
+        (
+            MultiIndex.from_product(
+                [["a"], ["b", "c"]], names=["index.name.0", "index.name.1"]
+            ),
+            "named_multi",
+        ),
+    ],
+)
+def test_to_html_basic_alignment(
+    datapath, row_index, row_type, column_index, column_type, index, header, index_names
+):
+    # GH 22747, GH 22579
+    df = DataFrame(np.zeros((2, 2), dtype=int), index=row_index, columns=column_index)
+    result = df.to_html(index=index, header=header, index_names=index_names)
+
+    if not index:
+        row_type = "none"
+    elif not index_names and row_type.startswith("named"):
+        row_type = "un" + row_type
+
+    if not header:
+        column_type = "none"
+    elif not index_names and column_type.startswith("named"):
+        column_type = "un" + column_type
+
+    filename = "index_" + row_type + "_columns_" + column_type
+    expected = expected_html(datapath, filename)
+    assert result == expected
+
+
+@pytest.mark.parametrize("index_names", [True, False])
+@pytest.mark.parametrize("header", [True, False])
+@pytest.mark.parametrize("index", [True, False])
+@pytest.mark.parametrize(
+    "column_index, column_type",
+    [
+        (Index(np.arange(8)), "unnamed_standard"),
+        (Index(np.arange(8), name="columns.name"), "named_standard"),
+        (
+            MultiIndex.from_product([["a", "b"], ["c", "d"], ["e", "f"]]),
+            "unnamed_multi",
+        ),
+        (
+            MultiIndex.from_product(
+                [["a", "b"], ["c", "d"], ["e", "f"]], names=["foo", None, "baz"]
+            ),
+            "named_multi",
+        ),
+    ],
+)
+@pytest.mark.parametrize(
+    "row_index, row_type",
+    [
+        (Index(np.arange(8)), "unnamed_standard"),
+        (Index(np.arange(8), name="index.name"), "named_standard"),
+        (
+            MultiIndex.from_product([["a", "b"], ["c", "d"], ["e", "f"]]),
+            "unnamed_multi",
+        ),
+        (
+            MultiIndex.from_product(
+                [["a", "b"], ["c", "d"], ["e", "f"]], names=["foo", None, "baz"]
+            ),
+            "named_multi",
+        ),
+    ],
+)
+def test_to_html_alignment_with_truncation(
+    datapath, row_index, row_type, column_index, column_type, index, header, index_names
+):
+    # GH 22747, GH 22579
+    df = DataFrame(np.arange(64).reshape(8, 8), index=row_index, columns=column_index)
+    result = df.to_html(
+        max_rows=4, max_cols=4, index=index, header=header, index_names=index_names
+    )
+
+    if not index:
+        row_type = "none"
+    elif not index_names and row_type.startswith("named"):
+        row_type = "un" + row_type
+
+    if not header:
+        column_type = "none"
+    elif not index_names and column_type.startswith("named"):
+        column_type = "un" + column_type
+
+    filename = "trunc_df_index_" + row_type + "_columns_" + column_type
+    expected = expected_html(datapath, filename)
+    assert result == expected
+
+
+@pytest.mark.parametrize("index", [False, 0])
+def test_to_html_truncation_index_false_max_rows(datapath, index):
+    # GH 15019
+    data = [
+        [1.764052, 0.400157],
+        [0.978738, 2.240893],
+        [1.867558, -0.977278],
+        [0.950088, -0.151357],
+        [-0.103219, 0.410599],
+    ]
+    df = DataFrame(data)
+    result = df.to_html(max_rows=4, index=index)
+    expected = expected_html(datapath, "gh15019_expected_output")
+    assert result == expected
+
+
+@pytest.mark.parametrize("index", [False, 0])
+@pytest.mark.parametrize(
+    "col_index_named, expected_output",
+    [(False, "gh22783_expected_output"), (True, "gh22783_named_columns_index")],
+)
+def test_to_html_truncation_index_false_max_cols(
+    datapath, index, col_index_named, expected_output
+):
+    # GH 22783
+    data = [
+        [1.764052, 0.400157, 0.978738, 2.240893, 1.867558],
+        [-0.977278, 0.950088, -0.151357, -0.103219, 0.410599],
+    ]
+    df = DataFrame(data)
+    if col_index_named:
+        df.columns.rename("columns.name", inplace=True)
+    result = df.to_html(max_cols=4, index=index)
+    expected = expected_html(datapath, expected_output)
+    assert result == expected
+
+
+@pytest.mark.parametrize("notebook", [True, False])
+def test_to_html_notebook_has_style(notebook):
+    df = DataFrame({"A": [1, 2, 3]})
+    result = df.to_html(notebook=notebook)
+
+    if notebook:
+        assert "tbody tr th:only-of-type" in result
+        assert "vertical-align: middle;" in result
+        assert "thead th" in result
+    else:
+        assert "tbody tr th:only-of-type" not in result
+        assert "vertical-align: middle;" not in result
+        assert "thead th" not in result
+
+
+def test_to_html_with_index_names_false():
+    # GH 16493
+    df = DataFrame({"A": [1, 2]}, index=Index(["a", "b"], name="myindexname"))
+    result = df.to_html(index_names=False)
+    assert "myindexname" not in result
+
+
+def test_to_html_with_id():
+    # GH 8496
+    df = DataFrame({"A": [1, 2]}, index=Index(["a", "b"], name="myindexname"))
+    result = df.to_html(index_names=False, table_id="TEST_ID")
+    assert ' id="TEST_ID"' in result
+
+
+@pytest.mark.parametrize(
+    "value,float_format,expected",
+    [
+        (0.19999, "%.3f", "gh21625_expected_output"),
+        (100.0, "%.0f", "gh22270_expected_output"),
+    ],
+)
+def test_to_html_float_format_no_fixed_width(value, float_format, expected, datapath):
+    # GH 21625, GH 22270
+    df = DataFrame({"x": [value]})
+    expected = expected_html(datapath, expected)
+    result = df.to_html(float_format=float_format)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "render_links,expected",
+    [(True, "render_links_true"), (False, "render_links_false")],
+)
+def test_to_html_render_links(render_links, expected, datapath):
+    # GH 2679
+    data = [
+        [0, "https://pandas.pydata.org/?q1=a&q2=b", "pydata.org"],
+        [0, "www.pydata.org", "pydata.org"],
+    ]
+    df = DataFrame(data, columns=Index(["foo", "bar", None], dtype=object))
+
+    result = df.to_html(render_links=render_links)
+    expected = expected_html(datapath, expected)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "method,expected",
+    [
+        ("to_html", lambda x: lorem_ipsum),
+        ("_repr_html_", lambda x: lorem_ipsum[: x - 4] + "..."),  # regression case
+    ],
+)
+@pytest.mark.parametrize("max_colwidth", [10, 20, 50, 100])
+def test_ignore_display_max_colwidth(method, expected, max_colwidth):
+    # see gh-17004
+    df = DataFrame([lorem_ipsum])
+    with option_context("display.max_colwidth", max_colwidth):
+        result = getattr(df, method)()
+    expected = expected(max_colwidth)
+    assert expected in result
+
+
+@pytest.mark.parametrize("classes", [True, 0])
+def test_to_html_invalid_classes_type(classes):
+    # GH 25608
+    df = DataFrame()
+    msg = "classes must be a string, list, or tuple"
+
+    with pytest.raises(TypeError, match=msg):
+        df.to_html(classes=classes)
+
+
+def test_to_html_round_column_headers():
+    # GH 17280
+    df = DataFrame([1], columns=[0.55555])
+    with option_context("display.precision", 3):
+        html = df.to_html(notebook=False)
+        notebook = df.to_html(notebook=True)
+    assert "0.55555" in html
+    assert "0.556" in notebook
+
+
+@pytest.mark.parametrize("unit", ["100px", "10%", "5em", 150])
+def test_to_html_with_col_space_units(unit):
+    # GH 25941
+    df = DataFrame(np.random.default_rng(2).random(size=(1, 3)))
+    result = df.to_html(col_space=unit)
+    result = result.split("tbody")[0]
+    hdrs = [x for x in result.split("\n") if re.search(r"<th[>\s]", x)]
+    if isinstance(unit, int):
+        unit = str(unit) + "px"
+    for h in hdrs:
+        expected = f'<th style="min-width: {unit};">'
+        assert expected in h
+
+
+class TestReprHTML:
+    def test_html_repr_min_rows_default(self, datapath):
+        # gh-27991
+
+        # default setting no truncation even if above min_rows
+        df = DataFrame({"a": range(20)})
+        result = df._repr_html_()
+        expected = expected_html(datapath, "html_repr_min_rows_default_no_truncation")
+        assert result == expected
+
+        # default of max_rows 60 triggers truncation if above
+        df = DataFrame({"a": range(61)})
+        result = df._repr_html_()
+        expected = expected_html(datapath, "html_repr_min_rows_default_truncated")
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "max_rows,min_rows,expected",
+        [
+            # truncated after first two rows
+            (10, 4, "html_repr_max_rows_10_min_rows_4"),
+            # when set to None, follow value of max_rows
+            (12, None, "html_repr_max_rows_12_min_rows_None"),
+            # when set value higher as max_rows, use the minimum
+            (10, 12, "html_repr_max_rows_10_min_rows_12"),
+            # max_rows of None -> never truncate
+            (None, 12, "html_repr_max_rows_None_min_rows_12"),
+        ],
+    )
+    def test_html_repr_min_rows(self, datapath, max_rows, min_rows, expected):
+        # gh-27991
+
+        df = DataFrame({"a": range(61)})
+        expected = expected_html(datapath, expected)
+        with option_context("display.max_rows", max_rows, "display.min_rows", min_rows):
+            result = df._repr_html_()
+        assert result == expected
+
+    def test_repr_html_ipython_config(self, ip):
+        code = textwrap.dedent(
+            """\
+        from pandas import DataFrame
+        df = DataFrame({"A": [1, 2]})
+        df._repr_html_()
+
+        cfg = get_ipython().config
+        cfg['IPKernelApp']['parent_appname']
+        df._repr_html_()
+        """
+        )
+        result = ip.run_cell(code, silent=True)
+        assert not result.error_in_exec
+
+    def test_info_repr_html(self):
+        max_rows = 60
+        max_cols = 20
+        # Long
+        h, w = max_rows + 1, max_cols - 1
+        df = DataFrame({k: np.arange(1, 1 + h) for k in np.arange(w)})
+        assert r"&lt;class" not in df._repr_html_()
+        with option_context("display.large_repr", "info"):
+            assert r"&lt;class" in df._repr_html_()
+
+        # Wide
+        h, w = max_rows - 1, max_cols + 1
+        df = DataFrame({k: np.arange(1, 1 + h) for k in np.arange(w)})
+        assert "<class" not in df._repr_html_()
+        with option_context(
+            "display.large_repr", "info", "display.max_columns", max_cols
+        ):
+            assert "&lt;class" in df._repr_html_()
+
+    def test_fake_qtconsole_repr_html(self, float_frame):
+        df = float_frame
+
+        def get_ipython():
+            return {"config": {"KernelApp": {"parent_appname": "ipython-qtconsole"}}}
+
+        repstr = df._repr_html_()
+        assert repstr is not None
+
+        with option_context("display.max_rows", 5, "display.max_columns", 2):
+            repstr = df._repr_html_()
+
+        assert "class" in repstr  # info fallback
+
+    def test_repr_html(self, float_frame):
+        df = float_frame
+        df._repr_html_()
+
+        with option_context("display.max_rows", 1, "display.max_columns", 1):
+            df._repr_html_()
+
+        with option_context("display.notebook_repr_html", False):
+            df._repr_html_()
+
+        df = DataFrame([[1, 2], [3, 4]])
+        with option_context("display.show_dimensions", True):
+            assert "2 rows" in df._repr_html_()
+        with option_context("display.show_dimensions", False):
+            assert "2 rows" not in df._repr_html_()
+
+    def test_repr_html_mathjax(self):
+        df = DataFrame([[1, 2], [3, 4]])
+        assert "tex2jax_ignore" not in df._repr_html_()
+        assert "mathjax_ignore" not in df._repr_html_()
+
+        with option_context("display.html.use_mathjax", False):
+            assert "tex2jax_ignore" in df._repr_html_()
+            assert "mathjax_ignore" in df._repr_html_()
+
+    def test_repr_html_wide(self):
+        max_cols = 20
+        df = DataFrame([["a" * 25] * (max_cols - 1)] * 10)
+        with option_context("display.max_rows", 60, "display.max_columns", 20):
+            assert "..." not in df._repr_html_()
+
+        wide_df = DataFrame([["a" * 25] * (max_cols + 1)] * 10)
+        with option_context("display.max_rows", 60, "display.max_columns", 20):
+            assert "..." in wide_df._repr_html_()
+
+    def test_repr_html_wide_multiindex_cols(self):
+        max_cols = 20
+
+        mcols = MultiIndex.from_product(
+            [np.arange(max_cols // 2), ["foo", "bar"]], names=["first", "second"]
+        )
+        df = DataFrame([["a" * 25] * len(mcols)] * 10, columns=mcols)
+        reg_repr = df._repr_html_()
+        assert "..." not in reg_repr
+
+        mcols = MultiIndex.from_product(
+            (np.arange(1 + (max_cols // 2)), ["foo", "bar"]), names=["first", "second"]
+        )
+        df = DataFrame([["a" * 25] * len(mcols)] * 10, columns=mcols)
+        with option_context("display.max_rows", 60, "display.max_columns", 20):
+            assert "..." in df._repr_html_()
+
+    def test_repr_html_long(self):
+        with option_context("display.max_rows", 60):
+            max_rows = get_option("display.max_rows")
+            h = max_rows - 1
+            df = DataFrame({"A": np.arange(1, 1 + h), "B": np.arange(41, 41 + h)})
+            reg_repr = df._repr_html_()
+            assert ".." not in reg_repr
+            assert str(41 + max_rows // 2) in reg_repr
+
+            h = max_rows + 1
+            df = DataFrame({"A": np.arange(1, 1 + h), "B": np.arange(41, 41 + h)})
+            long_repr = df._repr_html_()
+            assert ".." in long_repr
+            assert str(41 + max_rows // 2) not in long_repr
+            assert f"{h} rows " in long_repr
+            assert "2 columns" in long_repr
+
+    def test_repr_html_float(self):
+        with option_context("display.max_rows", 60):
+            max_rows = get_option("display.max_rows")
+            h = max_rows - 1
+            df = DataFrame(
+                {
+                    "idx": np.linspace(-10, 10, h),
+                    "A": np.arange(1, 1 + h),
+                    "B": np.arange(41, 41 + h),
+                }
+            ).set_index("idx")
+            reg_repr = df._repr_html_()
+            assert ".." not in reg_repr
+            assert f"<td>{40 + h}</td>" in reg_repr
+
+            h = max_rows + 1
+            df = DataFrame(
+                {
+                    "idx": np.linspace(-10, 10, h),
+                    "A": np.arange(1, 1 + h),
+                    "B": np.arange(41, 41 + h),
+                }
+            ).set_index("idx")
+            long_repr = df._repr_html_()
+            assert ".." in long_repr
+            assert "<td>31</td>" not in long_repr
+            assert f"{h} rows " in long_repr
+            assert "2 columns" in long_repr
+
+    def test_repr_html_long_multiindex(self):
+        max_rows = 60
+        max_L1 = max_rows // 2
+
+        tuples = list(itertools.product(np.arange(max_L1), ["foo", "bar"]))
+        idx = MultiIndex.from_tuples(tuples, names=["first", "second"])
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((max_L1 * 2, 2)),
+            index=idx,
+            columns=["A", "B"],
+        )
+        with option_context("display.max_rows", 60, "display.max_columns", 20):
+            reg_repr = df._repr_html_()
+        assert "..." not in reg_repr
+
+        tuples = list(itertools.product(np.arange(max_L1 + 1), ["foo", "bar"]))
+        idx = MultiIndex.from_tuples(tuples, names=["first", "second"])
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal(((max_L1 + 1) * 2, 2)),
+            index=idx,
+            columns=["A", "B"],
+        )
+        long_repr = df._repr_html_()
+        assert "..." in long_repr
+
+    def test_repr_html_long_and_wide(self):
+        max_cols = 20
+        max_rows = 60
+
+        h, w = max_rows - 1, max_cols - 1
+        df = DataFrame({k: np.arange(1, 1 + h) for k in np.arange(w)})
+        with option_context("display.max_rows", 60, "display.max_columns", 20):
+            assert "..." not in df._repr_html_()
+
+        h, w = max_rows + 1, max_cols + 1
+        df = DataFrame({k: np.arange(1, 1 + h) for k in np.arange(w)})
+        with option_context("display.max_rows", 60, "display.max_columns", 20):
+            assert "..." in df._repr_html_()
+
+
+def test_to_html_multilevel(multiindex_year_month_day_dataframe_random_data):
+    ymd = multiindex_year_month_day_dataframe_random_data
+
+    ymd.columns.name = "foo"
+    ymd.to_html()
+    ymd.T.to_html()
+
+
+@pytest.mark.parametrize("na_rep", ["NaN", "Ted"])
+def test_to_html_na_rep_and_float_format(na_rep, datapath):
+    # https://github.com/pandas-dev/pandas/issues/13828
+    df = DataFrame(
+        [
+            ["A", 1.2225],
+            ["A", None],
+        ],
+        columns=["Group", "Data"],
+    )
+    result = df.to_html(na_rep=na_rep, float_format="{:.2f}".format)
+    expected = expected_html(datapath, "gh13828_expected_output")
+    expected = expected.format(na_rep=na_rep)
+    assert result == expected
+
+
+def test_to_html_na_rep_non_scalar_data(datapath):
+    # GH47103
+    df = DataFrame([{"a": 1, "b": [1, 2, 3]}])
+    result = df.to_html(na_rep="-")
+    expected = expected_html(datapath, "gh47103_expected_output")
+    assert result == expected
+
+
+def test_to_html_float_format_object_col(datapath):
+    # GH#40024
+    df = DataFrame(data={"x": [1000.0, "test"]})
+    result = df.to_html(float_format=lambda x: f"{x:,.0f}")
+    expected = expected_html(datapath, "gh40024_expected_output")
+    assert result == expected
+
+
+def test_to_html_multiindex_col_with_colspace():
+    # GH#53885
+    df = DataFrame([[1, 2]])
+    df.columns = MultiIndex.from_tuples([(1, 1), (2, 1)])
+    result = df.to_html(col_space=100)
+    expected = (
+        '<table border="1" class="dataframe">\n'
+        "  <thead>\n"
+        "    <tr>\n"
+        '      <th style="min-width: 100px;"></th>\n'
+        '      <th style="min-width: 100px;">1</th>\n'
+        '      <th style="min-width: 100px;">2</th>\n'
+        "    </tr>\n"
+        "    <tr>\n"
+        '      <th style="min-width: 100px;"></th>\n'
+        '      <th style="min-width: 100px;">1</th>\n'
+        '      <th style="min-width: 100px;">1</th>\n'
+        "    </tr>\n"
+        "  </thead>\n"
+        "  <tbody>\n"
+        "    <tr>\n"
+        "      <th>0</th>\n"
+        "      <td>1</td>\n"
+        "      <td>2</td>\n"
+        "    </tr>\n"
+        "  </tbody>\n"
+        "</table>"
+    )
+    assert result == expected
+
+
+def test_to_html_tuple_col_with_colspace():
+    # GH#53885
+    df = DataFrame({("a", "b"): [1], "b": [2]})
+    result = df.to_html(col_space=100)
+    expected = (
+        '<table border="1" class="dataframe">\n'
+        "  <thead>\n"
+        '    <tr style="text-align: right;">\n'
+        '      <th style="min-width: 100px;"></th>\n'
+        '      <th style="min-width: 100px;">(a, b)</th>\n'
+        '      <th style="min-width: 100px;">b</th>\n'
+        "    </tr>\n"
+        "  </thead>\n"
+        "  <tbody>\n"
+        "    <tr>\n"
+        "      <th>0</th>\n"
+        "      <td>1</td>\n"
+        "      <td>2</td>\n"
+        "    </tr>\n"
+        "  </tbody>\n"
+        "</table>"
+    )
+    assert result == expected
+
+
+def test_to_html_empty_complex_array():
+    # GH#54167
+    df = DataFrame({"x": np.array([], dtype="complex")})
+    result = df.to_html(col_space=100)
+    expected = (
+        '<table border="1" class="dataframe">\n'
+        "  <thead>\n"
+        '    <tr style="text-align: right;">\n'
+        '      <th style="min-width: 100px;"></th>\n'
+        '      <th style="min-width: 100px;">x</th>\n'
+        "    </tr>\n"
+        "  </thead>\n"
+        "  <tbody>\n"
+        "  </tbody>\n"
+        "</table>"
+    )
+    assert result == expected

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_to_latex.py

@@ -0,0 +1,1527 @@
+from datetime import datetime
+from textwrap import dedent
+
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+)
+
+pytest.importorskip("jinja2")
+
+
+def _dedent(string):
+    """Dedent without new line in the beginning.
+
+    Built-in textwrap.dedent would keep new line character in the beginning
+    of multi-line string starting from the new line.
+    This version drops the leading new line character.
+    """
+    return dedent(string).lstrip()
+
+
+@pytest.fixture
+def df_short():
+    """Short dataframe for testing table/tabular/longtable LaTeX env."""
+    return DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+
+
+class TestToLatex:
+    def test_to_latex_to_file(self, float_frame, temp_file):
+        float_frame.to_latex(temp_file)
+        with open(temp_file, encoding="utf-8") as f:
+            assert float_frame.to_latex() == f.read()
+
+    def test_to_latex_to_file_utf8_with_encoding(self, temp_file):
+        # test with utf-8 and encoding option (GH 7061)
+        df = DataFrame([["au\xdfgangen"]])
+        df.to_latex(temp_file, encoding="utf-8")
+        with open(temp_file, encoding="utf-8") as f:
+            assert df.to_latex() == f.read()
+
+    def test_to_latex_to_file_utf8_without_encoding(self, temp_file):
+        # test with utf-8 without encoding option
+        df = DataFrame([["au\xdfgangen"]])
+        df.to_latex(temp_file)
+        with open(temp_file, encoding="utf-8") as f:
+            assert df.to_latex() == f.read()
+
+    def test_to_latex_tabular_with_index(self):
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex()
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_tabular_without_index(self):
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(index=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{rl}
+            \toprule
+            a & b \\
+            \midrule
+            1 & b1 \\
+            2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "bad_column_format",
+        [5, 1.2, ["l", "r"], ("r", "c"), {"r", "c", "l"}, {"a": "r", "b": "l"}],
+    )
+    def test_to_latex_bad_column_format(self, bad_column_format):
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        msg = r"`column_format` must be str or unicode"
+        with pytest.raises(ValueError, match=msg):
+            df.to_latex(column_format=bad_column_format)
+
+    def test_to_latex_column_format_just_works(self, float_frame):
+        # GH Bug #9402
+        float_frame.to_latex(column_format="lcr")
+
+    def test_to_latex_column_format(self):
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(column_format="lcr")
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lcr}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_float_format_object_col(self):
+        # GH#40024
+        ser = Series([1000.0, "test"])
+        result = ser.to_latex(float_format="{:,.0f}".format)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{ll}
+            \toprule
+             & 0 \\
+            \midrule
+            0 & 1,000 \\
+            1 & test \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_empty_tabular(self):
+        df = DataFrame()
+        result = df.to_latex()
+        expected = _dedent(
+            r"""
+            \begin{tabular}{l}
+            \toprule
+            \midrule
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_series(self):
+        s = Series(["a", "b", "c"])
+        result = s.to_latex()
+        expected = _dedent(
+            r"""
+            \begin{tabular}{ll}
+            \toprule
+             & 0 \\
+            \midrule
+            0 & a \\
+            1 & b \\
+            2 & c \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_midrule_location(self):
+        # GH 18326
+        df = DataFrame({"a": [1, 2]})
+        df.index.name = "foo"
+        result = df.to_latex(index_names=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lr}
+            \toprule
+             & a \\
+            \midrule
+            0 & 1 \\
+            1 & 2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+
+class TestToLatexLongtable:
+    def test_to_latex_empty_longtable(self):
+        df = DataFrame()
+        result = df.to_latex(longtable=True)
+        expected = _dedent(
+            r"""
+            \begin{longtable}{l}
+            \toprule
+            \midrule
+            \endfirsthead
+            \toprule
+            \midrule
+            \endhead
+            \midrule
+            \multicolumn{0}{r}{Continued on next page} \\
+            \midrule
+            \endfoot
+            \bottomrule
+            \endlastfoot
+            \end{longtable}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_longtable_with_index(self):
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(longtable=True)
+        expected = _dedent(
+            r"""
+            \begin{longtable}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            \endfirsthead
+            \toprule
+             & a & b \\
+            \midrule
+            \endhead
+            \midrule
+            \multicolumn{3}{r}{Continued on next page} \\
+            \midrule
+            \endfoot
+            \bottomrule
+            \endlastfoot
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \end{longtable}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_longtable_without_index(self):
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(index=False, longtable=True)
+        expected = _dedent(
+            r"""
+            \begin{longtable}{rl}
+            \toprule
+            a & b \\
+            \midrule
+            \endfirsthead
+            \toprule
+            a & b \\
+            \midrule
+            \endhead
+            \midrule
+            \multicolumn{2}{r}{Continued on next page} \\
+            \midrule
+            \endfoot
+            \bottomrule
+            \endlastfoot
+            1 & b1 \\
+            2 & b2 \\
+            \end{longtable}
+            """
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "df_data, expected_number",
+        [
+            ({"a": [1, 2]}, 1),
+            ({"a": [1, 2], "b": [3, 4]}, 2),
+            ({"a": [1, 2], "b": [3, 4], "c": [5, 6]}, 3),
+        ],
+    )
+    def test_to_latex_longtable_continued_on_next_page(self, df_data, expected_number):
+        df = DataFrame(df_data)
+        result = df.to_latex(index=False, longtable=True)
+        assert rf"\multicolumn{{{expected_number}}}" in result
+
+
+class TestToLatexHeader:
+    def test_to_latex_no_header_with_index(self):
+        # GH 7124
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(header=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrl}
+            \toprule
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_no_header_without_index(self):
+        # GH 7124
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(index=False, header=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{rl}
+            \toprule
+            \midrule
+            1 & b1 \\
+            2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_specified_header_with_index(self):
+        # GH 7124
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(header=["AA", "BB"])
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrl}
+            \toprule
+             & AA & BB \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_specified_header_without_index(self):
+        # GH 7124
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(header=["AA", "BB"], index=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{rl}
+            \toprule
+            AA & BB \\
+            \midrule
+            1 & b1 \\
+            2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "header, num_aliases",
+        [
+            (["A"], 1),
+            (("B",), 1),
+            (("Col1", "Col2", "Col3"), 3),
+            (("Col1", "Col2", "Col3", "Col4"), 4),
+        ],
+    )
+    def test_to_latex_number_of_items_in_header_missmatch_raises(
+        self,
+        header,
+        num_aliases,
+    ):
+        # GH 7124
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        msg = f"Writing 2 cols but got {num_aliases} aliases"
+        with pytest.raises(ValueError, match=msg):
+            df.to_latex(header=header)
+
+    def test_to_latex_decimal(self):
+        # GH 12031
+        df = DataFrame({"a": [1.0, 2.1], "b": ["b1", "b2"]})
+        result = df.to_latex(decimal=",")
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1,000000 & b1 \\
+            1 & 2,100000 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+
+class TestToLatexBold:
+    def test_to_latex_bold_rows(self):
+        # GH 16707
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(bold_rows=True)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            \textbf{0} & 1 & b1 \\
+            \textbf{1} & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_no_bold_rows(self):
+        # GH 16707
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(bold_rows=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+
+class TestToLatexCaptionLabel:
+    @pytest.fixture
+    def caption_table(self):
+        """Caption for table/tabular LaTeX environment."""
+        return "a table in a \\texttt{table/tabular} environment"
+
+    @pytest.fixture
+    def short_caption(self):
+        """Short caption for testing \\caption[short_caption]{full_caption}."""
+        return "a table"
+
+    @pytest.fixture
+    def label_table(self):
+        """Label for table/tabular LaTeX environment."""
+        return "tab:table_tabular"
+
+    @pytest.fixture
+    def caption_longtable(self):
+        """Caption for longtable LaTeX environment."""
+        return "a table in a \\texttt{longtable} environment"
+
+    @pytest.fixture
+    def label_longtable(self):
+        """Label for longtable LaTeX environment."""
+        return "tab:longtable"
+
+    def test_to_latex_caption_only(self, df_short, caption_table):
+        # GH 25436
+        result = df_short.to_latex(caption=caption_table)
+        expected = _dedent(
+            r"""
+            \begin{table}
+            \caption{a table in a \texttt{table/tabular} environment}
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            \end{table}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_label_only(self, df_short, label_table):
+        # GH 25436
+        result = df_short.to_latex(label=label_table)
+        expected = _dedent(
+            r"""
+            \begin{table}
+            \label{tab:table_tabular}
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            \end{table}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_caption_and_label(self, df_short, caption_table, label_table):
+        # GH 25436
+        result = df_short.to_latex(caption=caption_table, label=label_table)
+        expected = _dedent(
+            r"""
+            \begin{table}
+            \caption{a table in a \texttt{table/tabular} environment}
+            \label{tab:table_tabular}
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            \end{table}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_caption_and_shortcaption(
+        self,
+        df_short,
+        caption_table,
+        short_caption,
+    ):
+        result = df_short.to_latex(caption=(caption_table, short_caption))
+        expected = _dedent(
+            r"""
+            \begin{table}
+            \caption[a table]{a table in a \texttt{table/tabular} environment}
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            \end{table}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_caption_and_shortcaption_list_is_ok(self, df_short):
+        caption = ("Long-long-caption", "Short")
+        result_tuple = df_short.to_latex(caption=caption)
+        result_list = df_short.to_latex(caption=list(caption))
+        assert result_tuple == result_list
+
+    def test_to_latex_caption_shortcaption_and_label(
+        self,
+        df_short,
+        caption_table,
+        short_caption,
+        label_table,
+    ):
+        # test when the short_caption is provided alongside caption and label
+        result = df_short.to_latex(
+            caption=(caption_table, short_caption),
+            label=label_table,
+        )
+        expected = _dedent(
+            r"""
+            \begin{table}
+            \caption[a table]{a table in a \texttt{table/tabular} environment}
+            \label{tab:table_tabular}
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            \end{table}
+            """
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "bad_caption",
+        [
+            ("full_caption", "short_caption", "extra_string"),
+            ("full_caption", "short_caption", 1),
+            ("full_caption", "short_caption", None),
+            ("full_caption",),
+            (None,),
+        ],
+    )
+    def test_to_latex_bad_caption_raises(self, bad_caption):
+        # test that wrong number of params is raised
+        df = DataFrame({"a": [1]})
+        msg = "`caption` must be either a string or 2-tuple of strings"
+        with pytest.raises(ValueError, match=msg):
+            df.to_latex(caption=bad_caption)
+
+    def test_to_latex_two_chars_caption(self, df_short):
+        # test that two chars caption is handled correctly
+        # it must not be unpacked into long_caption, short_caption.
+        result = df_short.to_latex(caption="xy")
+        expected = _dedent(
+            r"""
+            \begin{table}
+            \caption{xy}
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            \end{table}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_longtable_caption_only(self, df_short, caption_longtable):
+        # GH 25436
+        # test when no caption and no label is provided
+        # is performed by test_to_latex_longtable()
+        result = df_short.to_latex(longtable=True, caption=caption_longtable)
+        expected = _dedent(
+            r"""
+            \begin{longtable}{lrl}
+            \caption{a table in a \texttt{longtable} environment} \\
+            \toprule
+             & a & b \\
+            \midrule
+            \endfirsthead
+            \caption[]{a table in a \texttt{longtable} environment} \\
+            \toprule
+             & a & b \\
+            \midrule
+            \endhead
+            \midrule
+            \multicolumn{3}{r}{Continued on next page} \\
+            \midrule
+            \endfoot
+            \bottomrule
+            \endlastfoot
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \end{longtable}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_longtable_label_only(self, df_short, label_longtable):
+        # GH 25436
+        result = df_short.to_latex(longtable=True, label=label_longtable)
+        expected = _dedent(
+            r"""
+            \begin{longtable}{lrl}
+            \label{tab:longtable} \\
+            \toprule
+             & a & b \\
+            \midrule
+            \endfirsthead
+            \toprule
+             & a & b \\
+            \midrule
+            \endhead
+            \midrule
+            \multicolumn{3}{r}{Continued on next page} \\
+            \midrule
+            \endfoot
+            \bottomrule
+            \endlastfoot
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \end{longtable}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_longtable_caption_and_label(
+        self,
+        df_short,
+        caption_longtable,
+        label_longtable,
+    ):
+        # GH 25436
+        result = df_short.to_latex(
+            longtable=True,
+            caption=caption_longtable,
+            label=label_longtable,
+        )
+        expected = _dedent(
+            r"""
+        \begin{longtable}{lrl}
+        \caption{a table in a \texttt{longtable} environment} \label{tab:longtable} \\
+        \toprule
+         & a & b \\
+        \midrule
+        \endfirsthead
+        \caption[]{a table in a \texttt{longtable} environment} \\
+        \toprule
+         & a & b \\
+        \midrule
+        \endhead
+        \midrule
+        \multicolumn{3}{r}{Continued on next page} \\
+        \midrule
+        \endfoot
+        \bottomrule
+        \endlastfoot
+        0 & 1 & b1 \\
+        1 & 2 & b2 \\
+        \end{longtable}
+        """
+        )
+        assert result == expected
+
+    def test_to_latex_longtable_caption_shortcaption_and_label(
+        self,
+        df_short,
+        caption_longtable,
+        short_caption,
+        label_longtable,
+    ):
+        # test when the caption, the short_caption and the label are provided
+        result = df_short.to_latex(
+            longtable=True,
+            caption=(caption_longtable, short_caption),
+            label=label_longtable,
+        )
+        expected = _dedent(
+            r"""
+\begin{longtable}{lrl}
+\caption[a table]{a table in a \texttt{longtable} environment} \label{tab:longtable} \\
+\toprule
+ & a & b \\
+\midrule
+\endfirsthead
+\caption[]{a table in a \texttt{longtable} environment} \\
+\toprule
+ & a & b \\
+\midrule
+\endhead
+\midrule
+\multicolumn{3}{r}{Continued on next page} \\
+\midrule
+\endfoot
+\bottomrule
+\endlastfoot
+0 & 1 & b1 \\
+1 & 2 & b2 \\
+\end{longtable}
+"""
+        )
+        assert result == expected
+
+
+class TestToLatexEscape:
+    @pytest.fixture
+    def df_with_symbols(self):
+        """Dataframe with special characters for testing chars escaping."""
+        a = "a"
+        b = "b"
+        return DataFrame({"co$e^x$": {a: "a", b: "b"}, "co^l1": {a: "a", b: "b"}})
+
+    def test_to_latex_escape_false(self, df_with_symbols):
+        result = df_with_symbols.to_latex(escape=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lll}
+            \toprule
+             & co$e^x$ & co^l1 \\
+            \midrule
+            a & a & a \\
+            b & b & b \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_escape_default(self, df_with_symbols):
+        # gh50871: in v2.0 escape is False by default (styler.format.escape=None)
+        default = df_with_symbols.to_latex()
+        specified_true = df_with_symbols.to_latex(escape=True)
+        assert default != specified_true
+
+    def test_to_latex_special_escape(self):
+        df = DataFrame([r"a\b\c", r"^a^b^c", r"~a~b~c"])
+        result = df.to_latex(escape=True)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{ll}
+            \toprule
+             & 0 \\
+            \midrule
+            0 & a\textbackslash b\textbackslash c \\
+            1 & \textasciicircum a\textasciicircum b\textasciicircum c \\
+            2 & \textasciitilde a\textasciitilde b\textasciitilde c \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_escape_special_chars(self):
+        special_characters = ["&", "%", "$", "#", "_", "{", "}", "~", "^", "\\"]
+        df = DataFrame(data=special_characters)
+        result = df.to_latex(escape=True)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{ll}
+            \toprule
+             & 0 \\
+            \midrule
+            0 & \& \\
+            1 & \% \\
+            2 & \$ \\
+            3 & \# \\
+            4 & \_ \\
+            5 & \{ \\
+            6 & \} \\
+            7 & \textasciitilde  \\
+            8 & \textasciicircum  \\
+            9 & \textbackslash  \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_escape_special_chars_in_index_names(self):
+        # https://github.com/pandas-dev/pandas/issues/61309
+        # https://github.com/pandas-dev/pandas/issues/57362
+        index = "&%$#_{}}~^\\"
+        df = DataFrame({index: [1, 2, 3]}).set_index(index)
+        result = df.to_latex(escape=True)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{l}
+            \toprule
+            \&\%\$\#\_\{\}\}\textasciitilde \textasciicircum \textbackslash  \\
+            \midrule
+            1 \\
+            2 \\
+            3 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_escape_special_chars_in_column_name(self):
+        df = DataFrame({"A": [1, 2, 3], "B": ["a", "b", "c"]})
+        df.columns.name = "_^~"
+        result = df.to_latex(escape=True)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrl}
+            \toprule
+            \_\textasciicircum \textasciitilde  & A & B \\
+            \midrule
+            0 & 1 & a \\
+            1 & 2 & b \\
+            2 & 3 & c \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_specified_header_special_chars_without_escape(self):
+        # GH 7124
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(header=["$A$", "$B$"], escape=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrl}
+            \toprule
+             & $A$ & $B$ \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+
+class TestToLatexPosition:
+    def test_to_latex_position(self):
+        the_position = "h"
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(position=the_position)
+        expected = _dedent(
+            r"""
+            \begin{table}[h]
+            \begin{tabular}{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \bottomrule
+            \end{tabular}
+            \end{table}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_longtable_position(self):
+        the_position = "t"
+        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+        result = df.to_latex(longtable=True, position=the_position)
+        expected = _dedent(
+            r"""
+            \begin{longtable}[t]{lrl}
+            \toprule
+             & a & b \\
+            \midrule
+            \endfirsthead
+            \toprule
+             & a & b \\
+            \midrule
+            \endhead
+            \midrule
+            \multicolumn{3}{r}{Continued on next page} \\
+            \midrule
+            \endfoot
+            \bottomrule
+            \endlastfoot
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
+            \end{longtable}
+            """
+        )
+        assert result == expected
+
+
+class TestToLatexFormatters:
+    def test_to_latex_with_formatters(self):
+        df = DataFrame(
+            {
+                "datetime64": [
+                    datetime(2016, 1, 1),
+                    datetime(2016, 2, 5),
+                    datetime(2016, 3, 3),
+                ],
+                "float": [1.0, 2.0, 3.0],
+                "int": [1, 2, 3],
+                "object": [(1, 2), True, False],
+            }
+        )
+
+        formatters = {
+            "datetime64": lambda x: x.strftime("%Y-%m"),
+            "float": lambda x: f"[{x: 4.1f}]",
+            "int": lambda x: f"0x{x:x}",
+            "object": lambda x: f"-{x!s}-",
+            "__index__": lambda x: f"index: {x}",
+        }
+        result = df.to_latex(formatters=dict(formatters))
+
+        expected = _dedent(
+            r"""
+            \begin{tabular}{llrrl}
+            \toprule
+             & datetime64 & float & int & object \\
+            \midrule
+            index: 0 & 2016-01 & [ 1.0] & 0x1 & -(1, 2)- \\
+            index: 1 & 2016-02 & [ 2.0] & 0x2 & -True- \\
+            index: 2 & 2016-03 & [ 3.0] & 0x3 & -False- \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_float_format_no_fixed_width_3decimals(self):
+        # GH 21625
+        df = DataFrame({"x": [0.19999]})
+        result = df.to_latex(float_format="%.3f")
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lr}
+            \toprule
+             & x \\
+            \midrule
+            0 & 0.200 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_float_format_no_fixed_width_integer(self):
+        # GH 22270
+        df = DataFrame({"x": [100.0]})
+        result = df.to_latex(float_format="%.0f")
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lr}
+            \toprule
+             & x \\
+            \midrule
+            0 & 100 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize("na_rep", ["NaN", "Ted"])
+    def test_to_latex_na_rep_and_float_format(self, na_rep):
+        df = DataFrame(
+            [
+                ["A", 1.2225],
+                ["A", None],
+            ],
+            columns=["Group", "Data"],
+        )
+        result = df.to_latex(na_rep=na_rep, float_format="{:.2f}".format)
+        expected = _dedent(
+            rf"""
+            \begin{{tabular}}{{llr}}
+            \toprule
+             & Group & Data \\
+            \midrule
+            0 & A & 1.22 \\
+            1 & A & {na_rep} \\
+            \bottomrule
+            \end{{tabular}}
+            """
+        )
+        assert result == expected
+
+
+class TestToLatexMultiindex:
+    @pytest.fixture
+    def multiindex_frame(self):
+        """Multiindex dataframe for testing multirow LaTeX macros."""
+        return DataFrame.from_dict(
+            {
+                ("c1", 0): Series({x: x for x in range(4)}),
+                ("c1", 1): Series({x: x + 4 for x in range(4)}),
+                ("c2", 0): Series({x: x for x in range(4)}),
+                ("c2", 1): Series({x: x + 4 for x in range(4)}),
+                ("c3", 0): Series({x: x for x in range(4)}),
+            }
+        ).T
+
+    @pytest.fixture
+    def multicolumn_frame(self):
+        """Multicolumn dataframe for testing multicolumn LaTeX macros."""
+        return DataFrame(
+            {
+                ("c1", 0): {x: x for x in range(5)},
+                ("c1", 1): {x: x + 5 for x in range(5)},
+                ("c2", 0): {x: x for x in range(5)},
+                ("c2", 1): {x: x + 5 for x in range(5)},
+                ("c3", 0): {x: x for x in range(5)},
+            }
+        )
+
+    def test_to_latex_multindex_header(self):
+        # GH 16718
+        df = DataFrame({"a": [0], "b": [1], "c": [2], "d": [3]})
+        df = df.set_index(["a", "b"])
+        observed = df.to_latex(header=["r1", "r2"], multirow=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{llrr}
+            \toprule
+             &  & r1 & r2 \\
+            a & b &  &  \\
+            \midrule
+            0 & 1 & 2 & 3 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert observed == expected
+
+    def test_to_latex_multiindex_empty_name(self):
+        # GH 18669
+        mi = pd.MultiIndex.from_product([[1, 2]], names=[""])
+        df = DataFrame(-1, index=mi, columns=range(4))
+        observed = df.to_latex()
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrrrr}
+            \toprule
+             & 0 & 1 & 2 & 3 \\
+             &  &  &  &  \\
+            \midrule
+            1 & -1 & -1 & -1 & -1 \\
+            2 & -1 & -1 & -1 & -1 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert observed == expected
+
+    def test_to_latex_multiindex_column_tabular(self):
+        df = DataFrame({("x", "y"): ["a"]})
+        result = df.to_latex()
+        expected = _dedent(
+            r"""
+            \begin{tabular}{ll}
+            \toprule
+             & x \\
+             & y \\
+            \midrule
+            0 & a \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multiindex_small_tabular(self):
+        df = DataFrame({("x", "y"): ["a"]}).T
+        result = df.to_latex(multirow=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lll}
+            \toprule
+             &  & 0 \\
+            \midrule
+            x & y & a \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multiindex_tabular(self, multiindex_frame):
+        result = multiindex_frame.to_latex(multirow=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{llrrrr}
+            \toprule
+             &  & 0 & 1 & 2 & 3 \\
+            \midrule
+            c1 & 0 & 0 & 1 & 2 & 3 \\
+             & 1 & 4 & 5 & 6 & 7 \\
+            c2 & 0 & 0 & 1 & 2 & 3 \\
+             & 1 & 4 & 5 & 6 & 7 \\
+            c3 & 0 & 0 & 1 & 2 & 3 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multicolumn_tabular(self, multiindex_frame):
+        # GH 14184
+        df = multiindex_frame.T
+        df.columns.names = ["a", "b"]
+        result = df.to_latex(multirow=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrrrrr}
+            \toprule
+            a & \multicolumn{2}{r}{c1} & \multicolumn{2}{r}{c2} & c3 \\
+            b & 0 & 1 & 0 & 1 & 0 \\
+            \midrule
+            0 & 0 & 4 & 0 & 4 & 0 \\
+            1 & 1 & 5 & 1 & 5 & 1 \\
+            2 & 2 & 6 & 2 & 6 & 2 \\
+            3 & 3 & 7 & 3 & 7 & 3 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_index_has_name_tabular(self):
+        # GH 10660
+        df = DataFrame({"a": [0, 0, 1, 1], "b": list("abab"), "c": [1, 2, 3, 4]})
+        result = df.set_index(["a", "b"]).to_latex(multirow=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{llr}
+            \toprule
+             &  & c \\
+            a & b &  \\
+            \midrule
+            0 & a & 1 \\
+             & b & 2 \\
+            1 & a & 3 \\
+             & b & 4 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_groupby_tabular(self):
+        # GH 10660
+        df = DataFrame({"a": [0, 0, 1, 1], "b": list("abab"), "c": [1, 2, 3, 4]})
+        result = (
+            df.groupby("a")
+            .describe()
+            .to_latex(float_format="{:.1f}".format, escape=True)
+        )
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrrrrrrrr}
+            \toprule
+             & \multicolumn{8}{r}{c} \\
+             & count & mean & std & min & 25\% & 50\% & 75\% & max \\
+            a &  &  &  &  &  &  &  &  \\
+            \midrule
+            0 & 2.0 & 1.5 & 0.7 & 1.0 & 1.2 & 1.5 & 1.8 & 2.0 \\
+            1 & 2.0 & 3.5 & 0.7 & 3.0 & 3.2 & 3.5 & 3.8 & 4.0 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multiindex_dupe_level(self):
+        # see gh-14484
+        #
+        # If an index is repeated in subsequent rows, it should be
+        # replaced with a blank in the created table. This should
+        # ONLY happen if all higher order indices (to the left) are
+        # equal too. In this test, 'c' has to be printed both times
+        # because the higher order index 'A' != 'B'.
+        df = DataFrame(
+            index=pd.MultiIndex.from_tuples([("A", "c"), ("B", "c")]), columns=["col"]
+        )
+        result = df.to_latex(multirow=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lll}
+            \toprule
+             &  & col \\
+            \midrule
+            A & c & NaN \\
+            B & c & NaN \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multicolumn_default(self, multicolumn_frame):
+        result = multicolumn_frame.to_latex()
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrrrrr}
+            \toprule
+             & \multicolumn{2}{r}{c1} & \multicolumn{2}{r}{c2} & c3 \\
+             & 0 & 1 & 0 & 1 & 0 \\
+            \midrule
+            0 & 0 & 5 & 0 & 5 & 0 \\
+            1 & 1 & 6 & 1 & 6 & 1 \\
+            2 & 2 & 7 & 2 & 7 & 2 \\
+            3 & 3 & 8 & 3 & 8 & 3 \\
+            4 & 4 & 9 & 4 & 9 & 4 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multicolumn_false(self, multicolumn_frame):
+        result = multicolumn_frame.to_latex(multicolumn=False, multicolumn_format="l")
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lrrrrr}
+            \toprule
+             & c1 & & c2 & & c3 \\
+             & 0 & 1 & 0 & 1 & 0 \\
+            \midrule
+            0 & 0 & 5 & 0 & 5 & 0 \\
+            1 & 1 & 6 & 1 & 6 & 1 \\
+            2 & 2 & 7 & 2 & 7 & 2 \\
+            3 & 3 & 8 & 3 & 8 & 3 \\
+            4 & 4 & 9 & 4 & 9 & 4 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multirow_true(self, multicolumn_frame):
+        result = multicolumn_frame.T.to_latex(multirow=True)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{llrrrrr}
+            \toprule
+             &  & 0 & 1 & 2 & 3 & 4 \\
+            \midrule
+            \multirow[t]{2}{*}{c1} & 0 & 0 & 1 & 2 & 3 & 4 \\
+             & 1 & 5 & 6 & 7 & 8 & 9 \\
+            \cline{1-7}
+            \multirow[t]{2}{*}{c2} & 0 & 0 & 1 & 2 & 3 & 4 \\
+             & 1 & 5 & 6 & 7 & 8 & 9 \\
+            \cline{1-7}
+            c3 & 0 & 0 & 1 & 2 & 3 & 4 \\
+            \cline{1-7}
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multicolumnrow_with_multicol_format(self, multicolumn_frame):
+        multicolumn_frame.index = multicolumn_frame.T.index
+        result = multicolumn_frame.T.to_latex(
+            multirow=True,
+            multicolumn=True,
+            multicolumn_format="c",
+        )
+        expected = _dedent(
+            r"""
+            \begin{tabular}{llrrrrr}
+            \toprule
+             &  & \multicolumn{2}{c}{c1} & \multicolumn{2}{c}{c2} & c3 \\
+             &  & 0 & 1 & 0 & 1 & 0 \\
+            \midrule
+            \multirow[t]{2}{*}{c1} & 0 & 0 & 1 & 2 & 3 & 4 \\
+             & 1 & 5 & 6 & 7 & 8 & 9 \\
+            \cline{1-7}
+            \multirow[t]{2}{*}{c2} & 0 & 0 & 1 & 2 & 3 & 4 \\
+             & 1 & 5 & 6 & 7 & 8 & 9 \\
+            \cline{1-7}
+            c3 & 0 & 0 & 1 & 2 & 3 & 4 \\
+            \cline{1-7}
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize("name0", [None, "named0"])
+    @pytest.mark.parametrize("name1", [None, "named1"])
+    @pytest.mark.parametrize("axes", [[0], [1], [0, 1]])
+    def test_to_latex_multiindex_names(self, name0, name1, axes):
+        # GH 18667
+        names = [name0, name1]
+        mi = pd.MultiIndex.from_product([[1, 2], [3, 4]])
+        df = DataFrame(-1, index=mi.copy(), columns=mi.copy())
+        for idx in axes:
+            df.axes[idx].names = names
+
+        idx_names = tuple(n or "" for n in names)
+        idx_names_row = (
+            f"{idx_names[0]} & {idx_names[1]} &  &  &  &  \\\\\n"
+            if (0 in axes and any(names))
+            else ""
+        )
+        col_names = [n if (bool(n) and 1 in axes) else "" for n in names]
+        observed = df.to_latex(multirow=False)
+        expected = r"""\begin{{tabular}}{{llrrrr}}
+\toprule
+ & {} & \multicolumn{{2}}{{r}}{{1}} & \multicolumn{{2}}{{r}}{{2}} \\
+ & {} & 3 & 4 & 3 & 4 \\
+{}\midrule
+1 & 3 & -1 & -1 & -1 & -1 \\
+ & 4 & -1 & -1 & -1 & -1 \\
+2 & 3 & -1 & -1 & -1 & -1 \\
+ & 4 & -1 & -1 & -1 & -1 \\
+\bottomrule
+\end{{tabular}}
+""".format(*col_names, idx_names_row)
+        assert observed == expected
+
+    @pytest.mark.parametrize("one_row", [True, False])
+    def test_to_latex_multiindex_nans(self, one_row):
+        # GH 14249
+        df = DataFrame({"a": [None, 1], "b": [2, 3], "c": [4, 5]})
+        if one_row:
+            df = df.iloc[[0]]
+        observed = df.set_index(["a", "b"]).to_latex(multirow=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{llr}
+            \toprule
+             &  & c \\
+            a & b &  \\
+            \midrule
+            NaN & 2 & 4 \\
+            """
+        )
+        if not one_row:
+            expected += r"""1.000000 & 3 & 5 \\
+"""
+        expected += r"""\bottomrule
+\end{tabular}
+"""
+        assert observed == expected
+
+    def test_to_latex_non_string_index(self):
+        # GH 19981
+        df = DataFrame([[1, 2, 3]] * 2).set_index([0, 1])
+        result = df.to_latex(multirow=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{llr}
+            \toprule
+             &  & 2 \\
+            0 & 1 &  \\
+            \midrule
+            1 & 2 & 3 \\
+             & 2 & 3 \\
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multiindex_multirow(self):
+        # GH 16719
+        mi = pd.MultiIndex.from_product(
+            [[0.0, 1.0], [3.0, 2.0, 1.0], ["0", "1"]], names=["i", "val0", "val1"]
+        )
+        df = DataFrame(index=mi)
+        result = df.to_latex(multirow=True, escape=False)
+        expected = _dedent(
+            r"""
+            \begin{tabular}{lll}
+            \toprule
+            i & val0 & val1 \\
+            \midrule
+            \multirow[t]{6}{*}{0.000000} & \multirow[t]{2}{*}{3.000000} & 0 \\
+             &  & 1 \\
+            \cline{2-3}
+             & \multirow[t]{2}{*}{2.000000} & 0 \\
+             &  & 1 \\
+            \cline{2-3}
+             & \multirow[t]{2}{*}{1.000000} & 0 \\
+             &  & 1 \\
+            \cline{1-3} \cline{2-3}
+            \multirow[t]{6}{*}{1.000000} & \multirow[t]{2}{*}{3.000000} & 0 \\
+             &  & 1 \\
+            \cline{2-3}
+             & \multirow[t]{2}{*}{2.000000} & 0 \\
+             &  & 1 \\
+            \cline{2-3}
+             & \multirow[t]{2}{*}{1.000000} & 0 \\
+             &  & 1 \\
+            \cline{1-3} \cline{2-3}
+            \bottomrule
+            \end{tabular}
+            """
+        )
+        assert result == expected
+
+    def test_to_latex_multiindex_format_single_index_hidden(self):
+        # GH 52218
+        df = DataFrame(
+            {
+                "A": [1, 2],
+                "B": [4, 5],
+            }
+        )
+        result = (
+            df.style.hide(axis="index")
+            .map_index(lambda v: "textbf:--rwrap;", axis="columns")
+            .to_latex()
+        )
+        expected = _dedent(r"""
+            \begin{tabular}{rr}
+            \textbf{A} & \textbf{B} \\
+            1 & 4 \\
+            2 & 5 \\
+            \end{tabular}
+            """)
+        assert result == expected
+
+    def test_to_latex_multiindex_format_triple_index_two_hidden(self):
+        # GH 52218
+        arrays = [
+            ["A", "A", "B", "B"],
+            ["one", "two", "one", "two"],
+            ["x", "x", "y", "y"],
+        ]
+        index = pd.MultiIndex.from_arrays(
+            arrays, names=["Level 0", "Level 1", "Level 2"]
+        )
+        df = DataFrame(
+            [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],
+            index=index,
+            columns=["C1", "C2", "C3"],
+        )
+        result = (
+            df.style.hide(axis="index", level=[0, 1])
+            .map_index(lambda v: "textbf:--rwrap;", axis="columns")
+            .to_latex()
+        )
+        expected = _dedent(r"""
+            \begin{tabular}{lrrr}
+             & \textbf{C1} & \textbf{C2} & \textbf{C3} \\
+            Level 2 &  &  &  \\
+            x & 0 & 0 & 0 \\
+            x & 0 & 0 & 0 \\
+            y & 0 & 0 & 0 \\
+            y & 0 & 0 & 0 \\
+            \end{tabular}
+            """)
+        assert result == expected
+
+    def test_to_latex_multiindex_format_triple_index_all_hidden(self):
+        # GH 52218
+        arrays = [
+            ["A", "A", "B", "B"],
+            ["one", "two", "one", "two"],
+            ["x", "x", "y", "y"],
+        ]
+        index = pd.MultiIndex.from_arrays(
+            arrays, names=["Level 0", "Level 1", "Level 2"]
+        )
+        df = DataFrame(
+            [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],
+            index=index,
+            columns=["C1", "C2", "C3"],
+        )
+        result = (
+            df.style.hide(axis="index", level=[0, 1, 2])
+            .map_index(lambda v: "textbf:--rwrap;", axis="columns")
+            .to_latex()
+        )
+        expected = _dedent(r"""
+            \begin{tabular}{rrr}
+            \textbf{C1} & \textbf{C2} & \textbf{C3} \\
+            0 & 0 & 0 \\
+            0 & 0 & 0 \\
+            0 & 0 & 0 \\
+            0 & 0 & 0 \\
+            \end{tabular}
+            """)
+        assert result == expected

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_to_markdown.py

@@ -0,0 +1,102 @@
+from io import StringIO
+
+import pytest
+
+from pandas.errors import Pandas4Warning
+
+import pandas as pd
+import pandas._testing as tm
+
+pytest.importorskip("tabulate")
+
+
+def test_keyword_deprecation():
+    # GH 57280
+    msg = (
+        "Starting with pandas version 4.0 all arguments of to_markdown "
+        "except for the argument 'buf' will be keyword-only."
+    )
+    s = pd.Series()
+    with tm.assert_produces_warning(Pandas4Warning, match=msg):
+        s.to_markdown(None, "wt")
+
+
+def test_simple():
+    buf = StringIO()
+    df = pd.DataFrame([1, 2, 3])
+    df.to_markdown(buf=buf)
+    result = buf.getvalue()
+    assert (
+        result == "|    |   0 |\n|---:|----:|\n|  0 |   1 |\n|  1 |   2 |\n|  2 |   3 |"
+    )
+
+
+def test_empty_frame():
+    buf = StringIO()
+    df = pd.DataFrame({"id": [], "first_name": [], "last_name": []}).set_index("id")
+    df.to_markdown(buf=buf)
+    result = buf.getvalue()
+    assert result == (
+        "| id   | first_name   | last_name   |\n|------|--------------|-------------|"
+    )
+
+
+def test_other_tablefmt():
+    buf = StringIO()
+    df = pd.DataFrame([1, 2, 3])
+    df.to_markdown(buf=buf, tablefmt="jira")
+    result = buf.getvalue()
+    assert result == "||    ||   0 ||\n|  0 |   1 |\n|  1 |   2 |\n|  2 |   3 |"
+
+
+def test_other_headers():
+    buf = StringIO()
+    df = pd.DataFrame([1, 2, 3])
+    df.to_markdown(buf=buf, headers=["foo", "bar"])
+    result = buf.getvalue()
+    assert result == (
+        "|   foo |   bar |\n|------:|------:|\n|     0 "
+        "|     1 |\n|     1 |     2 |\n|     2 |     3 |"
+    )
+
+
+def test_series():
+    buf = StringIO()
+    s = pd.Series([1, 2, 3], name="foo")
+    s.to_markdown(buf=buf)
+    result = buf.getvalue()
+    assert result == (
+        "|    |   foo |\n|---:|------:|\n|  0 |     1 |\n|  1 |     2 |\n|  2 |     3 |"
+    )
+
+
+def test_no_buf():
+    df = pd.DataFrame([1, 2, 3])
+    result = df.to_markdown()
+    assert (
+        result == "|    |   0 |\n|---:|----:|\n|  0 |   1 |\n|  1 |   2 |\n|  2 |   3 |"
+    )
+
+
+@pytest.mark.parametrize("index", [True, False])
+def test_index(index):
+    # GH 32667
+
+    df = pd.DataFrame([1, 2, 3])
+
+    result = df.to_markdown(index=index)
+
+    if index:
+        expected = (
+            "|    |   0 |\n|---:|----:|\n|  0 |   1 |\n|  1 |   2 |\n|  2 |   3 |"
+        )
+    else:
+        expected = "|   0 |\n|----:|\n|   1 |\n|   2 |\n|   3 |"
+    assert result == expected
+
+
+def test_showindex_disallowed_in_kwargs():
+    # GH 32667; disallowing showindex in kwargs enforced in 2.0
+    df = pd.DataFrame([1, 2, 3])
+    with pytest.raises(ValueError, match="Pass 'index' instead of 'showindex"):
+        df.to_markdown(index=True, showindex=True)

.venv/lib/python3.13/site-packages/pandas/tests/io/formats/test_to_string.py

@@ -0,0 +1,1226 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+from io import StringIO
+import re
+import sys
+from textwrap import dedent
+
+import numpy as np
+import pytest
+
+from pandas._config import using_string_dtype
+
+from pandas.errors import Pandas4Warning
+
+from pandas import (
+    CategoricalIndex,
+    DataFrame,
+    Index,
+    NaT,
+    Series,
+    Timestamp,
+    concat,
+    date_range,
+    get_option,
+    option_context,
+    read_csv,
+    timedelta_range,
+    to_datetime,
+)
+import pandas._testing as tm
+
+
+def _three_digit_exp():
+    return f"{1.7e8:.4g}" == "1.7e+008"
+
+
+class TestDataFrameToStringFormatters:
+    def test_keyword_deprecation(self):
+        # GH 57280
+        msg = (
+            "Starting with pandas version 4.0 all arguments of to_string "
+            "except for the argument 'buf' will be keyword-only."
+        )
+        s = Series(["a", "b"])
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            s.to_string(None, "NaN")
+
+    def test_to_string_masked_ea_with_formatter(self):
+        # GH#39336
+        df = DataFrame(
+            {
+                "a": Series([0.123456789, 1.123456789], dtype="Float64"),
+                "b": Series([1, 2], dtype="Int64"),
+            }
+        )
+        result = df.to_string(formatters=["{:.2f}".format, "{:.2f}".format])
+        expected = dedent(
+            """\
+                  a     b
+            0  0.12  1.00
+            1  1.12  2.00"""
+        )
+        assert result == expected
+
+    def test_to_string_with_formatters(self):
+        df = DataFrame(
+            {
+                "int": [1, 2, 3],
+                "float": [1.0, 2.0, 3.0],
+                "object": [(1, 2), True, False],
+            },
+            columns=["int", "float", "object"],
+        )
+
+        formatters = [
+            ("int", lambda x: f"0x{x:x}"),
+            ("float", lambda x: f"[{x: 4.1f}]"),
+            ("object", lambda x: f"-{x!s}-"),
+        ]
+        result = df.to_string(formatters=dict(formatters))
+        result2 = df.to_string(formatters=list(zip(*formatters))[1])
+        assert result == (
+            "  int  float    object\n"
+            "0 0x1 [ 1.0]  -(1, 2)-\n"
+            "1 0x2 [ 2.0]    -True-\n"
+            "2 0x3 [ 3.0]   -False-"
+        )
+        assert result == result2
+
+    def test_to_string_with_datetime64_monthformatter(self):
+        months = [datetime(2016, 1, 1), datetime(2016, 2, 2)]
+        x = DataFrame({"months": months})
+
+        def format_func(x):
+            return x.strftime("%Y-%m")
+
+        result = x.to_string(formatters={"months": format_func})
+        expected = dedent(
+            """\
+            months
+            0 2016-01
+            1 2016-02"""
+        )
+        assert result.strip() == expected
+
+    def test_to_string_with_datetime64_hourformatter(self):
+        x = DataFrame(
+            {"hod": to_datetime(["10:10:10.100", "12:12:12.120"], format="%H:%M:%S.%f")}
+        )
+
+        def format_func(x):
+            return x.strftime("%H:%M")
+
+        result = x.to_string(formatters={"hod": format_func})
+        expected = dedent(
+            """\
+            hod
+            0 10:10
+            1 12:12"""
+        )
+        assert result.strip() == expected
+
+    def test_to_string_with_formatters_unicode(self):
+        df = DataFrame({"c/\u03c3": [1, 2, 3]})
+        result = df.to_string(formatters={"c/\u03c3": str})
+        expected = dedent(
+            """\
+              c/\u03c3
+            0   1
+            1   2
+            2   3"""
+        )
+        assert result == expected
+
+    def test_to_string_index_formatter(self):
+        df = DataFrame([range(5), range(5, 10), range(10, 15)])
+        rs = df.to_string(formatters={"__index__": lambda x: "abc"[x]})
+        xp = dedent(
+            """\
+            0   1   2   3   4
+        a   0   1   2   3   4
+        b   5   6   7   8   9
+        c  10  11  12  13  14"""
+        )
+        assert rs == xp
+
+    def test_no_extra_space(self):
+        # GH#52690: Check that no extra space is given
+        col1 = "TEST"
+        col2 = "PANDAS"
+        col3 = "to_string"
+        expected = f"{col1:<6s} {col2:<7s} {col3:<10s}"
+        df = DataFrame([{"col1": "TEST", "col2": "PANDAS", "col3": "to_string"}])
+        d = {"col1": "{:<6s}".format, "col2": "{:<7s}".format, "col3": "{:<10s}".format}
+        result = df.to_string(index=False, header=False, formatters=d)
+        assert result == expected
+
+
+class TestDataFrameToStringColSpace:
+    def test_to_string_with_column_specific_col_space_raises(self):
+        df = DataFrame(
+            np.random.default_rng(2).random(size=(3, 3)), columns=["a", "b", "c"]
+        )
+
+        msg = (
+            "Col_space length\\(\\d+\\) should match "
+            "DataFrame number of columns\\(\\d+\\)"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.to_string(col_space=[30, 40])
+
+        with pytest.raises(ValueError, match=msg):
+            df.to_string(col_space=[30, 40, 50, 60])
+
+        msg = "unknown column"
+        with pytest.raises(ValueError, match=msg):
+            df.to_string(col_space={"a": "foo", "b": 23, "d": 34})
+
+    def test_to_string_with_column_specific_col_space(self):
+        df = DataFrame(
+            np.random.default_rng(2).random(size=(3, 3)), columns=["a", "b", "c"]
+        )
+
+        result = df.to_string(col_space={"a": 10, "b": 11, "c": 12})
+        # 3 separating space + each col_space for (id, a, b, c)
+        assert len(result.split("\n")[1]) == (3 + 1 + 10 + 11 + 12)
+
+        result = df.to_string(col_space=[10, 11, 12])
+        assert len(result.split("\n")[1]) == (3 + 1 + 10 + 11 + 12)
+
+    def test_to_string_with_col_space(self):
+        df = DataFrame(np.random.default_rng(2).random(size=(1, 3)))
+        c10 = len(df.to_string(col_space=10).split("\n")[1])
+        c20 = len(df.to_string(col_space=20).split("\n")[1])
+        c30 = len(df.to_string(col_space=30).split("\n")[1])
+        assert c10 < c20 < c30
+
+        # GH#8230
+        # col_space wasn't being applied with header=False
+        with_header = df.to_string(col_space=20)
+        with_header_row1 = with_header.splitlines()[1]
+        no_header = df.to_string(col_space=20, header=False)
+        assert len(with_header_row1) == len(no_header)
+
+    def test_to_string_repr_tuples(self):
+        buf = StringIO()
+
+        df = DataFrame({"tups": list(zip(range(10), range(10)))})
+        repr(df)
+        df.to_string(col_space=10, buf=buf)
+
+
+class TestDataFrameToStringHeader:
+    def test_to_string_header_false(self):
+        # GH#49230
+        df = DataFrame([1, 2])
+        df.index.name = "a"
+        s = df.to_string(header=False)
+        expected = "a   \n0  1\n1  2"
+        assert s == expected
+
+        df = DataFrame([[1, 2], [3, 4]])
+        df.index.name = "a"
+        s = df.to_string(header=False)
+        expected = "a      \n0  1  2\n1  3  4"
+        assert s == expected
+
+    def test_to_string_multindex_header(self):
+        # GH#16718
+        df = DataFrame({"a": [0], "b": [1], "c": [2], "d": [3]}).set_index(["a", "b"])
+        res = df.to_string(header=["r1", "r2"])
+        exp = "    r1 r2\na b      \n0 1  2  3"
+        assert res == exp
+
+    def test_to_string_no_header(self):
+        df = DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})
+
+        df_s = df.to_string(header=False)
+        expected = "0  1  4\n1  2  5\n2  3  6"
+
+        assert df_s == expected
+
+    def test_to_string_specified_header(self):
+        df = DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})
+
+        df_s = df.to_string(header=["X", "Y"])
+        expected = "   X  Y\n0  1  4\n1  2  5\n2  3  6"
+
+        assert df_s == expected
+
+        msg = "Writing 2 cols but got 1 aliases"
+        with pytest.raises(ValueError, match=msg):
+            df.to_string(header=["X"])
+
+
+class TestDataFrameToStringLineWidth:
+    def test_to_string_line_width(self):
+        df = DataFrame(123, index=range(10, 15), columns=range(30))
+        lines = df.to_string(line_width=80)
+        assert max(len(line) for line in lines.split("\n")) == 80
+
+    def test_to_string_line_width_no_index(self):
+        # GH#13998, GH#22505
+        df = DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})
+
+        df_s = df.to_string(line_width=1, index=False)
+        expected = " x  \\\n 1   \n 2   \n 3   \n\n y  \n 4  \n 5  \n 6  "
+
+        assert df_s == expected
+
+        df = DataFrame({"x": [11, 22, 33], "y": [4, 5, 6]})
+
+        df_s = df.to_string(line_width=1, index=False)
+        expected = " x  \\\n11   \n22   \n33   \n\n y  \n 4  \n 5  \n 6  "
+
+        assert df_s == expected
+
+        df = DataFrame({"x": [11, 22, -33], "y": [4, 5, -6]})
+
+        df_s = df.to_string(line_width=1, index=False)
+        expected = "  x  \\\n 11   \n 22   \n-33   \n\n y  \n 4  \n 5  \n-6  "
+
+        assert df_s == expected
+
+    def test_to_string_line_width_no_header(self):
+        # GH#53054
+        df = DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})
+
+        df_s = df.to_string(line_width=1, header=False)
+        expected = "0  1  \\\n1  2   \n2  3   \n\n0  4  \n1  5  \n2  6  "
+
+        assert df_s == expected
+
+        df = DataFrame({"x": [11, 22, 33], "y": [4, 5, 6]})
+
+        df_s = df.to_string(line_width=1, header=False)
+        expected = "0  11  \\\n1  22   \n2  33   \n\n0  4  \n1  5  \n2  6  "
+
+        assert df_s == expected
+
+        df = DataFrame({"x": [11, 22, -33], "y": [4, 5, -6]})
+
+        df_s = df.to_string(line_width=1, header=False)
+        expected = "0  11  \\\n1  22   \n2 -33   \n\n0  4  \n1  5  \n2 -6  "
+
+        assert df_s == expected
+
+    def test_to_string_line_width_with_both_index_and_header(self):
+        # GH#53054
+        df = DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})
+
+        df_s = df.to_string(line_width=1)
+        expected = (
+            "   x  \\\n0  1   \n1  2   \n2  3   \n\n   y  \n0  4  \n1  5  \n2  6  "
+        )
+
+        assert df_s == expected
+
+        df = DataFrame({"x": [11, 22, 33], "y": [4, 5, 6]})
+
+        df_s = df.to_string(line_width=1)
+        expected = (
+            "    x  \\\n0  11   \n1  22   \n2  33   \n\n   y  \n0  4  \n1  5  \n2  6  "
+        )
+
+        assert df_s == expected
+
+        df = DataFrame({"x": [11, 22, -33], "y": [4, 5, -6]})
+
+        df_s = df.to_string(line_width=1)
+        expected = (
+            "    x  \\\n0  11   \n1  22   \n2 -33   \n\n   y  \n0  4  \n1  5  \n2 -6  "
+        )
+
+        assert df_s == expected
+
+    def test_to_string_line_width_no_index_no_header(self):
+        # GH#53054
+        df = DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})
+
+        df_s = df.to_string(line_width=1, index=False, header=False)
+        expected = "1  \\\n2   \n3   \n\n4  \n5  \n6  "
+
+        assert df_s == expected
+
+        df = DataFrame({"x": [11, 22, 33], "y": [4, 5, 6]})
+
+        df_s = df.to_string(line_width=1, index=False, header=False)
+        expected = "11  \\\n22   \n33   \n\n4  \n5  \n6  "
+
+        assert df_s == expected
+
+        df = DataFrame({"x": [11, 22, -33], "y": [4, 5, -6]})
+
+        df_s = df.to_string(line_width=1, index=False, header=False)
+        expected = " 11  \\\n 22   \n-33   \n\n 4  \n 5  \n-6  "
+
+        assert df_s == expected
+
+
+class TestToStringNumericFormatting:
+    def test_to_string_float_format_no_fixed_width(self):
+        # GH#21625
+        df = DataFrame({"x": [0.19999]})
+        expected = "      x\n0 0.200"
+        assert df.to_string(float_format="%.3f") == expected
+
+        # GH#22270
+        df = DataFrame({"x": [100.0]})
+        expected = "    x\n0 100"
+        assert df.to_string(float_format="%.0f") == expected
+
+    def test_to_string_small_float_values(self):
+        df = DataFrame({"a": [1.5, 1e-17, -5.5e-7]})
+
+        result = df.to_string()
+        # sadness per above
+        if _three_digit_exp():
+            expected = (
+                "               a\n0  1.500000e+000\n1  1.000000e-017\n2 -5.500000e-007"
+            )
+        else:
+            expected = (
+                "              a\n0  1.500000e+00\n1  1.000000e-17\n2 -5.500000e-07"
+            )
+        assert result == expected
+
+        # but not all exactly zero
+        df = df * 0
+        result = df.to_string()
+        expected = "   0\n0  0\n1  0\n2 -0"
+        # TODO: assert that these match??
+
+    def test_to_string_complex_float_formatting(self):
+        # GH #25514, 25745
+        with option_context("display.precision", 5):
+            df = DataFrame(
+                {
+                    "x": [
+                        (0.4467846931321966 + 0.0715185102060818j),
+                        (0.2739442392974528 + 0.23515228785438969j),
+                        (0.26974928742135185 + 0.3250604054898979j),
+                        (-1j),
+                    ]
+                }
+            )
+            result = df.to_string()
+            expected = (
+                "                  x\n0  0.44678+0.07152j\n"
+                "1  0.27394+0.23515j\n"
+                "2  0.26975+0.32506j\n"
+                "3 -0.00000-1.00000j"
+            )
+            assert result == expected
+
+    def test_to_string_complex_float_formatting_with_exponents(self):
+        # GH #60393
+        with option_context("display.precision", 6):
+            df = DataFrame(
+                {
+                    "x": [
+                        (1.8816e-09 + 0j),
+                        (1.8816e-09 + 3.39676e-09j),
+                    ]
+                }
+            )
+            result = df.to_string()
+            expected = (
+                "                            x\n0  1.881600e-09+0.000000e+00j\n"
+                "1  1.881600e-09+3.396760e-09j"
+            )
+            assert result == expected
+
+    def test_to_string_format_inf(self):
+        # GH#24861
+        df = DataFrame(
+            {
+                "A": [-np.inf, np.inf, -1, -2.1234, 3, 4],
+                "B": [-np.inf, np.inf, "foo", "foooo", "fooooo", "bar"],
+            }
+        )
+        result = df.to_string()
+
+        expected = (
+            "        A       B\n"
+            "0    -inf    -inf\n"
+            "1     inf     inf\n"
+            "2 -1.0000     foo\n"
+            "3 -2.1234   foooo\n"
+            "4  3.0000  fooooo\n"
+            "5  4.0000     bar"
+        )
+        assert result == expected
+
+        df = DataFrame(
+            {
+                "A": [-np.inf, np.inf, -1.0, -2.0, 3.0, 4.0],
+                "B": [-np.inf, np.inf, "foo", "foooo", "fooooo", "bar"],
+            }
+        )
+        result = df.to_string()
+
+        expected = (
+            "     A       B\n"
+            "0 -inf    -inf\n"
+            "1  inf     inf\n"
+            "2 -1.0     foo\n"
+            "3 -2.0   foooo\n"
+            "4  3.0  fooooo\n"
+            "5  4.0     bar"
+        )
+        assert result == expected
+
+    def test_to_string_int_formatting(self):
+        df = DataFrame({"x": [-15, 20, 25, -35]})
+        assert issubclass(df["x"].dtype.type, np.integer)
+
+        output = df.to_string()
+        expected = "    x\n0 -15\n1  20\n2  25\n3 -35"
+        assert output == expected
+
+    def test_to_string_float_formatting(self):
+        with option_context(
+            "display.precision",
+            5,
+            "display.notebook_repr_html",
+            False,
+        ):
+            df = DataFrame(
+                {"x": [0, 0.25, 3456.000, 12e45, 1.64e6, 1.7e8, 1.253456, np.pi, -1e6]}
+            )
+
+            df_s = df.to_string()
+
+            if _three_digit_exp():
+                expected = (
+                    "              x\n0  0.00000e+000\n1  2.50000e-001\n"
+                    "2  3.45600e+003\n3  1.20000e+046\n4  1.64000e+006\n"
+                    "5  1.70000e+008\n6  1.25346e+000\n7  3.14159e+000\n"
+                    "8 -1.00000e+006"
+                )
+            else:
+                expected = (
+                    "             x\n0  0.00000e+00\n1  2.50000e-01\n"
+                    "2  3.45600e+03\n3  1.20000e+46\n4  1.64000e+06\n"
+                    "5  1.70000e+08\n6  1.25346e+00\n7  3.14159e+00\n"
+                    "8 -1.00000e+06"
+                )
+            assert df_s == expected
+
+            df = DataFrame({"x": [3234, 0.253]})
+            df_s = df.to_string()
+
+            expected = "          x\n0  3234.000\n1     0.253"
+            assert df_s == expected
+
+        assert get_option("display.precision") == 6
+
+        df = DataFrame({"x": [1e9, 0.2512]})
+        df_s = df.to_string()
+
+        if _three_digit_exp():
+            expected = "               x\n0  1.000000e+009\n1  2.512000e-001"
+        else:
+            expected = "              x\n0  1.000000e+09\n1  2.512000e-01"
+        assert df_s == expected
+
+
+class TestDataFrameToString:
+    def test_to_string_decimal(self):
+        # GH#23614
+        df = DataFrame({"A": [6.0, 3.1, 2.2]})
+        expected = "     A\n0  6,0\n1  3,1\n2  2,2"
+        assert df.to_string(decimal=",") == expected
+
+    def test_to_string_left_justify_cols(self):
+        df = DataFrame({"x": [3234, 0.253]})
+        df_s = df.to_string(justify="left")
+        expected = "   x       \n0  3234.000\n1     0.253"
+        assert df_s == expected
+
+    def test_to_string_format_na(self):
+        df = DataFrame(
+            {
+                "A": [np.nan, -1, -2.1234, 3, 4],
+                "B": [np.nan, "foo", "foooo", "fooooo", "bar"],
+            }
+        )
+        result = df.to_string()
+
+        expected = (
+            "        A       B\n"
+            "0     NaN     NaN\n"
+            "1 -1.0000     foo\n"
+            "2 -2.1234   foooo\n"
+            "3  3.0000  fooooo\n"
+            "4  4.0000     bar"
+        )
+        assert result == expected
+
+        df = DataFrame(
+            {
+                "A": [np.nan, -1.0, -2.0, 3.0, 4.0],
+                "B": [np.nan, "foo", "foooo", "fooooo", "bar"],
+            }
+        )
+        result = df.to_string()
+
+        expected = (
+            "     A       B\n"
+            "0  NaN     NaN\n"
+            "1 -1.0     foo\n"
+            "2 -2.0   foooo\n"
+            "3  3.0  fooooo\n"
+            "4  4.0     bar"
+        )
+        assert result == expected
+
+    def test_to_string_with_dict_entries(self):
+        df = DataFrame({"A": [{"a": 1, "b": 2}]})
+
+        val = df.to_string()
+        assert "'a': 1" in val
+        assert "'b': 2" in val
+
+    def test_to_string_with_categorical_columns(self):
+        # GH#35439
+        data = [[4, 2], [3, 2], [4, 3]]
+        cols = ["aaaaaaaaa", "b"]
+        df = DataFrame(data, columns=cols)
+        df_cat_cols = DataFrame(data, columns=CategoricalIndex(cols))
+
+        assert df.to_string() == df_cat_cols.to_string()
+
+    def test_repr_embedded_ndarray(self):
+        arr = np.empty(10, dtype=[("err", object)])
+        for i in range(len(arr)):
+            arr["err"][i] = np.random.default_rng(2).standard_normal(i)
+
+        df = DataFrame(arr)
+        repr(df["err"])
+        repr(df)
+        df.to_string()
+
+    def test_to_string_truncate(self):
+        # GH 9784 - dont truncate when calling DataFrame.to_string
+        df = DataFrame(
+            [
+                {
+                    "a": "foo",
+                    "b": "bar",
+                    "c": "let's make this a very VERY long line that is longer "
+                    "than the default 50 character limit",
+                    "d": 1,
+                },
+                {"a": "foo", "b": "bar", "c": "stuff", "d": 1},
+            ]
+        )
+        df.set_index(["a", "b", "c"])
+        assert df.to_string() == (
+            "     a    b                                         "
+            "                                                c  d\n"
+            "0  foo  bar  let's make this a very VERY long line t"
+            "hat is longer than the default 50 character limit  1\n"
+            "1  foo  bar                                         "
+            "                                            stuff  1"
+        )
+        with option_context("max_colwidth", 20):
+            # the display option has no effect on the to_string method
+            assert df.to_string() == (
+                "     a    b                                         "
+                "                                                c  d\n"
+                "0  foo  bar  let's make this a very VERY long line t"
+                "hat is longer than the default 50 character limit  1\n"
+                "1  foo  bar                                         "
+                "                                            stuff  1"
+            )
+        assert df.to_string(max_colwidth=20) == (
+            "     a    b                    c  d\n"
+            "0  foo  bar  let's make this ...  1\n"
+            "1  foo  bar                stuff  1"
+        )
+
+    @pytest.mark.parametrize(
+        "input_array, expected",
+        [
+            ({"A": ["a"]}, "A\na"),
+            ({"A": ["a", "b"], "B": ["c", "dd"]}, "A  B\na  c\nb dd"),
+            ({"A": ["a", 1], "B": ["aa", 1]}, "A  B\na aa\n1  1"),
+        ],
+    )
+    def test_format_remove_leading_space_dataframe(self, input_array, expected):
+        # GH#24980
+        df = DataFrame(input_array).to_string(index=False)
+        assert df == expected
+
+    @pytest.mark.parametrize(
+        "data,expected",
+        [
+            (
+                {"col1": [1, 2], "col2": [3, 4]},
+                "   col1  col2\n0     1     3\n1     2     4",
+            ),
+            (
+                {"col1": ["Abc", 0.756], "col2": [np.nan, 4.5435]},
+                "    col1    col2\n0    Abc     NaN\n1  0.756  4.5435",
+            ),
+            (
+                {"col1": [np.nan, "a"], "col2": [0.009, 3.543], "col3": ["Abc", 23]},
+                "  col1   col2 col3\n0  NaN  0.009  Abc\n1    a  3.543   23",
+            ),
+        ],
+    )
+    def test_to_string_max_rows_zero(self, data, expected):
+        # GH#35394
+        result = DataFrame(data=data).to_string(max_rows=0)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "max_cols, max_rows, expected",
+        [
+            (
+                10,
+                None,
+                " 0   1   2   3   4   ...  6   7   8   9   10\n"
+                "  0   0   0   0   0  ...   0   0   0   0   0\n"
+                "  0   0   0   0   0  ...   0   0   0   0   0\n"
+                "  0   0   0   0   0  ...   0   0   0   0   0\n"
+                "  0   0   0   0   0  ...   0   0   0   0   0",
+            ),
+            (
+                None,
+                2,
+                " 0   1   2   3   4   5   6   7   8   9   10\n"
+                "  0   0   0   0   0   0   0   0   0   0   0\n"
+                " ..  ..  ..  ..  ..  ..  ..  ..  ..  ..  ..\n"
+                "  0   0   0   0   0   0   0   0   0   0   0",
+            ),
+            (
+                10,
+                2,
+                " 0   1   2   3   4   ...  6   7   8   9   10\n"
+                "  0   0   0   0   0  ...   0   0   0   0   0\n"
+                " ..  ..  ..  ..  ..  ...  ..  ..  ..  ..  ..\n"
+                "  0   0   0   0   0  ...   0   0   0   0   0",
+            ),
+            (
+                9,
+                2,
+                " 0   1   2   3   ...  7   8   9   10\n"
+                "  0   0   0   0  ...   0   0   0   0\n"
+                " ..  ..  ..  ..  ...  ..  ..  ..  ..\n"
+                "  0   0   0   0  ...   0   0   0   0",
+            ),
+            (
+                1,
+                1,
+                " 0  ...\n 0  ...\n..  ...",
+            ),
+        ],
+    )
+    def test_truncation_no_index(self, max_cols, max_rows, expected):
+        df = DataFrame([[0] * 11] * 4)
+        assert (
+            df.to_string(index=False, max_cols=max_cols, max_rows=max_rows) == expected
+        )
+
+    def test_to_string_no_index(self):
+        # GH#16839, GH#13032
+        df = DataFrame({"x": [11, 22], "y": [33, -44], "z": ["AAA", "   "]})
+
+        df_s = df.to_string(index=False)
+        # Leading space is expected for positive numbers.
+        expected = " x   y   z\n11  33 AAA\n22 -44    "
+        assert df_s == expected
+
+        df_s = df[["y", "x", "z"]].to_string(index=False)
+        expected = "  y  x   z\n 33 11 AAA\n-44 22    "
+        assert df_s == expected
+
+    def test_to_string_unicode_columns(self, float_frame):
+        df = DataFrame({"\u03c3": np.arange(10.0)})
+
+        buf = StringIO()
+        df.to_string(buf=buf)
+        buf.getvalue()
+
+        buf = StringIO()
+        df.info(buf=buf)
+        buf.getvalue()
+
+        result = float_frame.to_string()
+        assert isinstance(result, str)
+
+    @pytest.mark.parametrize("na_rep", ["NaN", "Ted"])
+    def test_to_string_na_rep_and_float_format(self, na_rep):
+        # GH#13828
+        df = DataFrame([["A", 1.2225], ["A", None]], columns=["Group", "Data"])
+        result = df.to_string(na_rep=na_rep, float_format="{:.2f}".format)
+        expected = dedent(
+            f"""\
+               Group  Data
+             0     A  1.22
+             1     A   {na_rep}"""
+        )
+        assert result == expected
+
+    def test_to_string_string_dtype(self):
+        # GH#50099
+        pytest.importorskip("pyarrow")
+        df = DataFrame(
+            {"x": ["foo", "bar", "baz"], "y": ["a", "b", "c"], "z": [1, 2, 3]}
+        )
+        df = df.astype(
+            {"x": "string[pyarrow]", "y": "string[python]", "z": "int64[pyarrow]"}
+        )
+        result = df.dtypes.to_string()
+        expected = dedent(
+            """\
+            x            string
+            y            string
+            z    int64[pyarrow]"""
+        )
+        assert result == expected
+
+    def test_to_string_utf8_columns(self):
+        n = "\u05d0".encode()
+        df = DataFrame([1, 2], columns=[n])
+
+        with option_context("display.max_rows", 1):
+            repr(df)
+
+    def test_to_string_unicode_two(self):
+        dm = DataFrame({"c/\u03c3": []})
+        buf = StringIO()
+        dm.to_string(buf)
+
+    def test_to_string_unicode_three(self):
+        dm = DataFrame(["\xc2"])
+        buf = StringIO()
+        dm.to_string(buf)
+
+    def test_to_string_with_float_index(self):
+        index = Index([1.5, 2, 3, 4, 5])
+        df = DataFrame(np.arange(5), index=index)
+
+        result = df.to_string()
+        expected = "     0\n1.5  0\n2.0  1\n3.0  2\n4.0  3\n5.0  4"
+        assert result == expected
+
+    def test_to_string(self):
+        # big mixed
+        biggie = DataFrame(
+            {
+                "A": np.random.default_rng(2).standard_normal(200),
+                "B": Index([f"{i}?!" for i in range(200)]),
+            },
+        )
+
+        biggie.loc[:20, "A"] = np.nan
+        biggie.loc[:20, "B"] = np.nan
+        s = biggie.to_string()
+
+        buf = StringIO()
+        retval = biggie.to_string(buf=buf)
+        assert retval is None
+        assert buf.getvalue() == s
+
+        assert isinstance(s, str)
+
+        # print in right order
+        result = biggie.to_string(
+            columns=["B", "A"], col_space=17, float_format="%.5f".__mod__
+        )
+        lines = result.split("\n")
+        header = lines[0].strip().split()
+        joined = "\n".join([re.sub(r"\s+", " ", x).strip() for x in lines[1:]])
+        recons = read_csv(StringIO(joined), names=header, header=None, sep=" ")
+        tm.assert_series_equal(recons["B"], biggie["B"])
+        assert recons["A"].count() == biggie["A"].count()
+        assert (np.abs(recons["A"].dropna() - biggie["A"].dropna()) < 0.1).all()
+
+        # FIXME: don't leave commented-out
+        # expected = ['B', 'A']
+        # assert header == expected
+
+        result = biggie.to_string(columns=["A"], col_space=17)
+        header = result.split("\n")[0].strip().split()
+        expected = ["A"]
+        assert header == expected
+
+        biggie.to_string(columns=["B", "A"], formatters={"A": lambda x: f"{x:.1f}"})
+
+        biggie.to_string(columns=["B", "A"], float_format=str)
+        biggie.to_string(columns=["B", "A"], col_space=12, float_format=str)
+
+        frame = DataFrame(index=np.arange(200))
+        frame.to_string()
+
+    # TODO: split or simplify this test?
+    @pytest.mark.xfail(using_string_dtype(), reason="fix when arrow is default")
+    def test_to_string_index_with_nan(self):
+        # GH#2850
+        df = DataFrame(
+            {
+                "id1": {0: "1a3", 1: "9h4"},
+                "id2": {0: np.nan, 1: "d67"},
+                "id3": {0: "78d", 1: "79d"},
+                "value": {0: 123, 1: 64},
+            }
+        )
+
+        # multi-index
+        y = df.set_index(["id1", "id2", "id3"])
+        result = y.to_string()
+        expected = (
+            "             value\nid1 id2 id3       \n"
+            "1a3 NaN 78d    123\n9h4 d67 79d     64"
+        )
+        assert result == expected
+
+        # index
+        y = df.set_index("id2")
+        result = y.to_string()
+        expected = (
+            "     id1  id3  value\nid2                 \n"
+            "NaN  1a3  78d    123\nd67  9h4  79d     64"
+        )
+        assert result == expected
+
+        # with append (this failed in 0.12)
+        y = df.set_index(["id1", "id2"]).set_index("id3", append=True)
+        result = y.to_string()
+        expected = (
+            "             value\nid1 id2 id3       \n"
+            "1a3 NaN 78d    123\n9h4 d67 79d     64"
+        )
+        assert result == expected
+
+        # all-nan in mi
+        df2 = df.copy()
+        df2.loc[:, "id2"] = np.nan
+        y = df2.set_index("id2")
+        result = y.to_string()
+        expected = (
+            "     id1  id3  value\nid2                 \n"
+            "NaN  1a3  78d    123\nNaN  9h4  79d     64"
+        )
+        assert result == expected
+
+        # partial nan in mi
+        df2 = df.copy()
+        df2.loc[:, "id2"] = np.nan
+        y = df2.set_index(["id2", "id3"])
+        result = y.to_string()
+        expected = (
+            "         id1  value\nid2 id3            \n"
+            "NaN 78d  1a3    123\n    79d  9h4     64"
+        )
+        assert result == expected
+
+        df = DataFrame(
+            {
+                "id1": {0: np.nan, 1: "9h4"},
+                "id2": {0: np.nan, 1: "d67"},
+                "id3": {0: np.nan, 1: "79d"},
+                "value": {0: 123, 1: 64},
+            }
+        )
+
+        y = df.set_index(["id1", "id2", "id3"])
+        result = y.to_string()
+        expected = (
+            "             value\nid1 id2 id3       \n"
+            "NaN NaN NaN    123\n9h4 d67 79d     64"
+        )
+        assert result == expected
+
+    def test_to_string_nonunicode_nonascii_alignment(self):
+        df = DataFrame([["aa\xc3\xa4\xc3\xa4", 1], ["bbbb", 2]])
+        rep_str = df.to_string()
+        lines = rep_str.split("\n")
+        assert len(lines[1]) == len(lines[2])
+
+    def test_unicode_problem_decoding_as_ascii(self):
+        df = DataFrame({"c/\u03c3": Series({"test": np.nan})})
+        str(df.to_string())
+
+    def test_to_string_repr_unicode(self):
+        buf = StringIO()
+
+        unicode_values = ["\u03c3"] * 10
+        unicode_values = np.array(unicode_values, dtype=object)
+        df = DataFrame({"unicode": unicode_values})
+        df.to_string(col_space=10, buf=buf)
+
+        # it works!
+        repr(df)
+        # it works even if sys.stdin in None
+        _stdin = sys.stdin
+        try:
+            sys.stdin = None
+            repr(df)
+        finally:
+            sys.stdin = _stdin
+
+    def test_nested_dataframe(self):
+        df1 = DataFrame({"level1": [["row1"], ["row2"]]})
+        df2 = DataFrame({"level3": [{"level2": df1}]})
+        result = df2.to_string()
+        expected = "                   level3\n0  {'level2': ['level1']}"
+        assert result == expected
+
+
+class TestSeriesToString:
+    def test_to_string_without_index(self):
+        # GH#11729 Test index=False option
+        ser = Series([1, 2, 3, 4])
+        result = ser.to_string(index=False)
+        expected = "\n".join(["1", "2", "3", "4"])
+        assert result == expected
+
+    def test_to_string_name(self):
+        ser = Series(range(100), dtype="int64")
+        ser.name = "myser"
+        res = ser.to_string(max_rows=2, name=True)
+        exp = "0      0\n      ..\n99    99\nName: myser"
+        assert res == exp
+        res = ser.to_string(max_rows=2, name=False)
+        exp = "0      0\n      ..\n99    99"
+        assert res == exp
+
+    def test_to_string_dtype(self):
+        ser = Series(range(100), dtype="int64")
+        res = ser.to_string(max_rows=2, dtype=True)
+        exp = "0      0\n      ..\n99    99\ndtype: int64"
+        assert res == exp
+        res = ser.to_string(max_rows=2, dtype=False)
+        exp = "0      0\n      ..\n99    99"
+        assert res == exp
+
+    def test_to_string_length(self):
+        ser = Series(range(100), dtype="int64")
+        res = ser.to_string(max_rows=2, length=True)
+        exp = "0      0\n      ..\n99    99\nLength: 100"
+        assert res == exp
+
+    def test_to_string_na_rep(self):
+        ser = Series(index=range(100), dtype=np.float64)
+        res = ser.to_string(na_rep="foo", max_rows=2)
+        exp = "0    foo\n      ..\n99   foo"
+        assert res == exp
+
+    def test_to_string_float_format(self):
+        ser = Series(range(10), dtype="float64")
+        res = ser.to_string(float_format=lambda x: f"{x:2.1f}", max_rows=2)
+        exp = "0   0.0\n     ..\n9   9.0"
+        assert res == exp
+
+    def test_to_string_header(self):
+        ser = Series(range(10), dtype="int64")
+        ser.index.name = "foo"
+        res = ser.to_string(header=True, max_rows=2)
+        exp = "foo\n0    0\n    ..\n9    9"
+        assert res == exp
+        res = ser.to_string(header=False, max_rows=2)
+        exp = "0    0\n    ..\n9    9"
+        assert res == exp
+
+    def test_to_string_empty_col(self):
+        # GH#13653
+        ser = Series(["", "Hello", "World", "", "", "Mooooo", "", ""])
+        res = ser.to_string(index=False)
+        exp = "      \n Hello\n World\n      \n      \nMooooo\n      \n      "
+        assert re.match(exp, res)
+
+    def test_to_string_timedelta64(self):
+        Series(np.array([1100, 20], dtype="timedelta64[ns]")).to_string()
+
+        ser = Series(date_range("2012-1-1", periods=3, freq="D"))
+
+        # GH#2146
+
+        # adding NaTs
+        y = ser - ser.shift(1)
+        result = y.to_string()
+        assert "1 days" in result
+        assert "00:00:00" not in result
+        assert "NaT" in result
+
+        # with frac seconds
+        o = Series([datetime(2012, 1, 1, microsecond=150)] * 3)
+        y = ser - o
+        result = y.to_string()
+        assert "-1 days +23:59:59.999850" in result
+
+        # rounding?
+        o = Series([datetime(2012, 1, 1, 1)] * 3)
+        y = ser - o
+        result = y.to_string()
+        assert "-1 days +23:00:00" in result
+        assert "1 days 23:00:00" in result
+
+        o = Series([datetime(2012, 1, 1, 1, 1)] * 3)
+        y = ser - o
+        result = y.to_string()
+        assert "-1 days +22:59:00" in result
+        assert "1 days 22:59:00" in result
+
+        o = Series([datetime(2012, 1, 1, 1, 1, microsecond=150)] * 3)
+        y = ser - o
+        result = y.to_string()
+        assert "-1 days +22:58:59.999850" in result
+        assert "0 days 22:58:59.999850" in result
+
+        # neg time
+        td = timedelta(minutes=5, seconds=3)
+        s2 = Series(date_range("2012-1-1", periods=3, freq="D")) + td
+        y = ser - s2
+        result = y.to_string()
+        assert "-1 days +23:54:57" in result
+
+        td = timedelta(microseconds=550)
+        s2 = Series(date_range("2012-1-1", periods=3, freq="D")) + td
+        y = ser - td
+        result = y.to_string()
+        assert "2012-01-01 23:59:59.999450" in result
+
+        # no boxing of the actual elements
+        td = Series(timedelta_range("1 days", periods=3))
+        result = td.to_string()
+        assert result == "0   1 days\n1   2 days\n2   3 days"
+
+    def test_to_string(self):
+        ts = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10, freq="B"),
+        )
+        buf = StringIO()
+
+        s = ts.to_string()
+
+        retval = ts.to_string(buf=buf)
+        assert retval is None
+        assert buf.getvalue().strip() == s
+
+        # pass float_format
+        format = "%.4f".__mod__
+        result = ts.to_string(float_format=format)
+        result = [x.split()[1] for x in result.split("\n")[:-1]]
+        expected = [format(x) for x in ts]
+        assert result == expected
+
+        # empty string
+        result = ts[:0].to_string()
+        assert result == "Series([], Freq: B)"
+
+        result = ts[:0].to_string(length=0)
+        assert result == "Series([], Freq: B)"
+
+        # name and length
+        cp = ts.copy()
+        cp.name = "foo"
+        result = cp.to_string(length=True, name=True, dtype=True)
+        last_line = result.split("\n")[-1].strip()
+        assert last_line == (f"Freq: B, Name: foo, Length: {len(cp)}, dtype: float64")
+
+    @pytest.mark.parametrize(
+        "input_array, expected",
+        [
+            ("a", "a"),
+            (["a", "b"], "a\nb"),
+            ([1, "a"], "1\na"),
+            (1, "1"),
+            ([0, -1], " 0\n-1"),
+            (1.0, "1.0"),
+            ([" a", " b"], " a\n b"),
+            ([".1", "1"], ".1\n 1"),
+            (["10", "-10"], " 10\n-10"),
+        ],
+    )
+    def test_format_remove_leading_space_series(self, input_array, expected):
+        # GH: 24980
+        ser = Series(input_array)
+        result = ser.to_string(index=False)
+        assert result == expected
+
+    def test_to_string_complex_number_trims_zeros(self):
+        ser = Series([1.000000 + 1.000000j, 1.0 + 1.0j, 1.05 + 1.0j])
+        result = ser.to_string()
+        expected = dedent(
+            """\
+            0    1.00+1.00j
+            1    1.00+1.00j
+            2    1.05+1.00j"""
+        )
+        assert result == expected
+
+    def test_nullable_float_to_string(self, float_ea_dtype):
+        # https://github.com/pandas-dev/pandas/issues/36775
+        dtype = float_ea_dtype
+        ser = Series([0.0, 1.0, None], dtype=dtype)
+        result = ser.to_string()
+        expected = dedent(
+            """\
+            0     0.0
+            1     1.0
+            2    <NA>"""
+        )
+        assert result == expected
+
+    def test_nullable_int_to_string(self, any_int_ea_dtype):
+        # https://github.com/pandas-dev/pandas/issues/36775
+        dtype = any_int_ea_dtype
+        ser = Series([0, 1, None], dtype=dtype)
+        result = ser.to_string()
+        expected = dedent(
+            """\
+            0       0
+            1       1
+            2    <NA>"""
+        )
+        assert result == expected
+
+    def test_to_string_mixed(self):
+        ser = Series(["foo", np.nan, -1.23, 4.56])
+        result = ser.to_string()
+        expected = "".join(["0     foo\n", "1     NaN\n", "2   -1.23\n", "3    4.56"])
+        assert result == expected
+
+        # but don't count NAs as floats
+        ser = Series(["foo", np.nan, "bar", "baz"])
+        result = ser.to_string()
+        expected = "".join(["0    foo\n", "1    NaN\n", "2    bar\n", "3    baz"])
+        assert result == expected
+
+        ser = Series(["foo", 5, "bar", "baz"])
+        result = ser.to_string()
+        expected = "".join(["0    foo\n", "1      5\n", "2    bar\n", "3    baz"])
+        assert result == expected
+
+    def test_to_string_float_na_spacing(self):
+        ser = Series([0.0, 1.5678, 2.0, -3.0, 4.0])
+        ser[::2] = np.nan
+
+        result = ser.to_string()
+        expected = "0       NaN\n1    1.5678\n2       NaN\n3   -3.0000\n4       NaN"
+        assert result == expected
+
+    def test_to_string_with_datetimeindex(self):
+        index = date_range("20130102", periods=6)
+        ser = Series(1, index=index)
+        result = ser.to_string()
+        assert "2013-01-02" in result
+
+        # nat in index
+        s2 = Series(2, index=[Timestamp("20130111"), NaT])
+        ser = concat([s2, ser])
+        result = ser.to_string()
+        assert "NaT" in result
+
+        # nat in summary
+        result = str(s2.index)
+        assert "NaT" in result

.venv/lib/python3.13/site-packages/pandas/tests/io/generate_legacy_storage_files.py

@@ -0,0 +1,421 @@
+"""
+self-contained to write legacy storage pickle files
+
+To use this script. Create an environment where you want
+generate pickles, say its for 0.20.3, with your pandas clone
+in ~/pandas
+
+. activate pandas_0.20.3
+cd ~/pandas/pandas
+
+$ python -m tests.io.generate_legacy_storage_files \
+    tests/io/data/legacy_pickle/0.20.3/ pickle
+
+This script generates a storage file for the current arch, system,
+and python version
+  pandas version: 0.20.3
+  output dir    : pandas/pandas/tests/io/data/legacy_pickle/0.20.3/
+  storage format: pickle
+created pickle file: 0.20.3_x86_64_darwin_3.5.2.pickle
+
+The idea here is you are using the *current* version of the
+generate_legacy_storage_files with an *older* version of pandas to
+generate a pickle file. We will then check this file into a current
+branch, and test using test_pickle.py. This will load the *older*
+pickles and test versus the current data that is generated
+(with main). These are then compared.
+
+If we have cases where we changed the signature (e.g. we renamed
+offset -> freq in Timestamp). Then we have to conditionally execute
+in the generate_legacy_storage_files.py to make it
+run under the older AND the newer version.
+
+"""
+
+from datetime import timedelta
+import os
+import pickle
+import platform as pl
+import sys
+
+# Remove script directory from path, otherwise Python will try to
+# import the JSON test directory as the json module
+sys.path.pop(0)
+
+import numpy as np
+
+import pandas
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    MultiIndex,
+    NaT,
+    Period,
+    RangeIndex,
+    Series,
+    Timestamp,
+    bdate_range,
+    date_range,
+    interval_range,
+    period_range,
+    timedelta_range,
+)
+from pandas.arrays import SparseArray
+
+from pandas.tseries.offsets import (
+    FY5253,
+    BusinessDay,
+    BusinessHour,
+    CustomBusinessDay,
+    DateOffset,
+    Day,
+    Easter,
+    Hour,
+    LastWeekOfMonth,
+    Minute,
+    MonthBegin,
+    MonthEnd,
+    QuarterBegin,
+    QuarterEnd,
+    SemiMonthBegin,
+    SemiMonthEnd,
+    Week,
+    WeekOfMonth,
+    YearBegin,
+    YearEnd,
+)
+
+
+def _create_sp_series():
+    nan = np.nan
+
+    # nan-based
+    arr = np.arange(15, dtype=np.float64)
+    arr[7:12] = nan
+    arr[-1:] = nan
+
+    bseries = Series(SparseArray(arr, kind="block"))
+    bseries.name = "bseries"
+    return bseries
+
+
+def _create_sp_tsseries():
+    nan = np.nan
+
+    # nan-based
+    arr = np.arange(15, dtype=np.float64)
+    arr[7:12] = nan
+    arr[-1:] = nan
+
+    date_index = bdate_range("1/1/2011", periods=len(arr))
+    bseries = Series(SparseArray(arr, kind="block"), index=date_index)
+    bseries.name = "btsseries"
+    return bseries
+
+
+def _create_sp_frame():
+    nan = np.nan
+
+    data = {
+        "A": [nan, nan, nan, 0, 1, 2, 3, 4, 5, 6],
+        "B": [0, 1, 2, nan, nan, nan, 3, 4, 5, 6],
+        "C": np.arange(10).astype(np.int64),
+        "D": [0, 1, 2, 3, 4, 5, nan, nan, nan, nan],
+    }
+
+    dates = bdate_range("1/1/2011", periods=10)
+    return DataFrame(data, index=dates).apply(SparseArray)
+
+
+def create_pickle_data(test: bool = True):
+    """create the pickle data"""
+    data = {
+        "A": [0.0, 1.0, 2.0, 3.0, np.nan],
+        "B": [0, 1, 0, 1, 0],
+        "C": ["foo1", "foo2", "foo3", "foo4", "foo5"],
+        "D": date_range("1/1/2009", periods=5),
+        "E": [0.0, 1, Timestamp("20100101"), "foo", 2.0],
+    }
+
+    scalars = {"timestamp": Timestamp("20130101"), "period": Period("2012", "M")}
+
+    index = {
+        "int": Index(np.arange(10)),
+        "date": date_range("20130101", periods=10),
+        "period": period_range("2013-01-01", freq="M", periods=10),
+        "float": Index(np.arange(10, dtype=np.float64)),
+        "uint": Index(np.arange(10, dtype=np.uint64)),
+        "timedelta": timedelta_range("00:00:00", freq="30min", periods=10),
+        "string": Index(["foo", "bar", "baz", "qux", "quux"], dtype="string"),
+    }
+
+    index["range"] = RangeIndex(10)
+
+    index["interval"] = interval_range(0, periods=10)
+
+    mi = {
+        "reg2": MultiIndex.from_tuples(
+            tuple(
+                zip(
+                    *[
+                        ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+                        ["one", "two", "one", "two", "one", "two", "one", "two"],
+                    ]
+                )
+            ),
+            names=["first", "second"],
+        )
+    }
+
+    series = {
+        "float": Series(data["A"]),
+        "int": Series(data["B"]),
+        "mixed": Series(data["E"]),
+        "ts": Series(
+            np.arange(10).astype(np.int64), index=date_range("20130101", periods=10)
+        ),
+        "mi": Series(
+            np.arange(5).astype(np.float64),
+            index=MultiIndex.from_tuples(
+                tuple(zip(*[[1, 1, 2, 2, 2], [3, 4, 3, 4, 5]])), names=["one", "two"]
+            ),
+        ),
+        "dup": Series(np.arange(5).astype(np.float64), index=["A", "B", "C", "D", "A"]),
+        "cat": Series(Categorical(["foo", "bar", "baz"])),
+        "dt": Series(date_range("20130101", periods=5)),
+        "dt_tz": Series(date_range("20130101", periods=5, tz="US/Eastern")),
+        "period": Series([Period("2000Q1")] * 5),
+        "string": Series(["foo", "bar", "baz", "qux", "quux"], dtype="string"),
+    }
+
+    mixed_dup_df = DataFrame(data)
+    mixed_dup_df.columns = list("ABCDA")
+    frame = {
+        "float": DataFrame({"A": series["float"], "B": series["float"] + 1}),
+        "int": DataFrame({"A": series["int"], "B": series["int"] + 1}),
+        "mixed": DataFrame({k: data[k] for k in ["A", "B", "C", "D"]}),
+        "mi": DataFrame(
+            {"A": np.arange(5).astype(np.float64), "B": np.arange(5).astype(np.int64)},
+            index=MultiIndex.from_tuples(
+                tuple(
+                    zip(
+                        *[
+                            ["bar", "bar", "baz", "baz", "baz"],
+                            ["one", "two", "one", "two", "three"],
+                        ]
+                    )
+                ),
+                names=["first", "second"],
+            ),
+        ),
+        "dup": DataFrame(
+            np.arange(15).reshape(5, 3).astype(np.float64), columns=["A", "B", "A"]
+        ),
+        "cat_onecol": DataFrame({"A": Categorical(["foo", "bar"])}),
+        "cat_and_float": DataFrame(
+            {
+                "A": Categorical(["foo", "bar", "baz"]),
+                "B": np.arange(3).astype(np.int64),
+            }
+        ),
+        "mixed_dup": mixed_dup_df,
+        "dt_mixed_tzs": DataFrame(
+            {
+                "A": Timestamp("20130102", tz="US/Eastern"),
+                "B": Timestamp("20130603", tz="CET"),
+            },
+            index=range(5),
+        ),
+        "dt_mixed2_tzs": DataFrame(
+            {
+                "A": Timestamp("20130102", tz="US/Eastern"),
+                "B": Timestamp("20130603", tz="CET"),
+                "C": Timestamp("20130603", tz="UTC"),
+            },
+            index=range(5),
+        ),
+        "string": DataFrame(
+            {
+                "A": Series(["foo", "bar", "baz", "qux", "quux"], dtype="string"),
+                "B": Series(["one", "two", "one", "two", "three"], dtype="string"),
+            }
+        ),
+    }
+
+    cat = {
+        "int8": Categorical(list("abcdefg")),
+        "int16": Categorical(np.arange(1000)),
+        "int32": Categorical(np.arange(10000)),
+    }
+
+    timestamp = {
+        "normal": Timestamp("2011-01-01"),
+        "nat": NaT,
+        "tz": Timestamp("2011-01-01", tz="US/Eastern"),
+    }
+    if test:
+        # kept because those are present in the legacy pickles (<= 1.4)
+        timestamp["freq"] = Timestamp("2011-01-01")
+        timestamp["both"] = Timestamp("2011-01-01", tz="Asia/Tokyo")
+
+    off = {
+        "DateOffset": DateOffset(years=1),
+        "DateOffset_h_ns": DateOffset(hour=6, nanoseconds=5824),
+        "BusinessDay": BusinessDay(offset=timedelta(seconds=9)),
+        "BusinessHour": BusinessHour(normalize=True, n=6, end="15:14"),
+        "CustomBusinessDay": CustomBusinessDay(weekmask="Mon Fri"),
+        "SemiMonthBegin": SemiMonthBegin(day_of_month=9),
+        "SemiMonthEnd": SemiMonthEnd(day_of_month=24),
+        "MonthBegin": MonthBegin(1),
+        "MonthEnd": MonthEnd(1),
+        "QuarterBegin": QuarterBegin(1),
+        "QuarterEnd": QuarterEnd(1),
+        "Day": Day(1),
+        "YearBegin": YearBegin(1),
+        "YearEnd": YearEnd(1),
+        "Week": Week(1),
+        "Week_Tues": Week(2, normalize=False, weekday=1),
+        "WeekOfMonth": WeekOfMonth(week=3, weekday=4),
+        "LastWeekOfMonth": LastWeekOfMonth(n=1, weekday=3),
+        "FY5253": FY5253(n=2, weekday=6, startingMonth=7, variation="last"),
+        "Easter": Easter(),
+        "Hour": Hour(1),
+        "Minute": Minute(1),
+    }
+
+    return {
+        "series": series,
+        "frame": frame,
+        "index": index,
+        "scalars": scalars,
+        "mi": mi,
+        "sp_series": {"float": _create_sp_series(), "ts": _create_sp_tsseries()},
+        "sp_frame": {"float": _create_sp_frame()},
+        "cat": cat,
+        "timestamp": timestamp,
+        "offsets": off,
+    }
+
+
+def create_dataframe_all_types():
+    timestamps = Series(
+        [
+            Timestamp("2013-01-01"),
+            NaT,
+            Timestamp("2013-01-03"),
+            Timestamp("2013-01-04"),
+            Timestamp("2013-01-05"),
+        ]
+    )
+    timedeltas = timestamps - timestamps[0]
+
+    data = {
+        # "string": Series(
+        #     ["a", "b", "c", None, "e"], dtype=StringDtype(na_value=np.nan)
+        # ),
+        # "object": Series(["a", "b", "c", None, "e"], dtype=object),
+        # "object_nan": Series(["a", "b", "c", np.nan, "e"], dtype=object),
+        "int": list(range(1, 6)),
+        "uint64": np.arange(3, 8).astype("uint64"),
+        "float": [0.1, 0.2, 0.3, 0.4, np.nan],
+        "float32": Series([0.1, 0.2, 0.3, 0.4, np.nan], dtype="float32"),
+        "bool": [True, False, True, False, True],
+        "datetime_ns": timestamps.dt.as_unit("ns"),
+        "datetime_us": timestamps.dt.as_unit("us"),
+        "datetime_ms": timestamps.dt.as_unit("ms"),
+        "datetime_s": timestamps.dt.as_unit("s"),
+        "datetimetz_ns": timestamps.dt.tz_localize("US/Eastern").dt.as_unit("ns"),
+        "datetimetz_us": timestamps.dt.tz_localize("US/Eastern").dt.as_unit("us"),
+        "timedelta_ns": timedeltas.dt.as_unit("ns"),
+        "timedelta_us": timedeltas.dt.as_unit("us"),
+        "timedelta_ms": timedeltas.dt.as_unit("ms"),
+        "timedelta_s": timedeltas.dt.as_unit("s"),
+        # "categorical": Categorical(
+        #     Series(
+        #         ["foo", "bar", "baz",np.nan,"foo"],dtype=StringDtype(na_value=np.nan)
+        #     )
+        # ),
+        # "categorical_object": Categorical(
+        #     Series(["foo", "bar", "baz", np.nan, "foo"], dtype=object)
+        # ),
+        "categorical_int": Categorical([1, 2, 3, np.nan, 1]),
+    }
+    return DataFrame(data)
+
+
+def platform_name():
+    return "_".join(
+        [
+            str(pandas.__version__),
+            str(pl.machine()),
+            str(pl.system().lower()),
+            str(pl.python_version()),
+        ]
+    )
+
+
+def write_legacy_pickles(output_dir):
+    pth = f"{platform_name()}.pickle"
+
+    with open(os.path.join(output_dir, pth), "wb") as fh:
+        pickle.dump(create_pickle_data(test=False), fh, pickle.DEFAULT_PROTOCOL)
+
+    print(f"created pickle file: {pth}")
+
+
+def write_legacy_hdf(output_dir, format):
+    import tables
+
+    pth = f"{platform_name()}_pytables-{tables.__version__}_{format}.h5"
+
+    df = create_dataframe_all_types()
+    if format == "fixed":
+        # df = df.drop(columns=["categorical", "categorical_object", "categorical_int"])
+        df = df.drop(columns=["categorical_int"])
+    complevel = 9 if format == "table" else None
+    df.to_hdf(
+        os.path.join(output_dir, pth),
+        key="df_alltypes",
+        format=format,
+        complevel=complevel,
+    )
+
+    print(f"created hdf file: {pth}")
+
+
+def write_legacy_file():
+    # force our cwd to be the first searched
+    sys.path.insert(0, "")
+
+    if not 3 <= len(sys.argv) <= 4:
+        sys.exit(
+            "Specify output directory and storage type: generate_legacy_"
+            "storage_files.py <output_dir> <storage_type> "
+        )
+
+    output_dir = str(sys.argv[1])
+    storage_type = str(sys.argv[2])
+
+    print(
+        "This script generates a storage file for the current arch, system, "
+        "and python version"
+    )
+    print(f"  pandas version: {pandas.__version__}")
+    print(f"  output dir    : {output_dir}")
+    print(f"  storage format: {storage_type}")
+
+    if not os.path.exists(output_dir):
+        os.mkdir(output_dir)
+
+    if storage_type == "pickle":
+        write_legacy_pickles(output_dir=output_dir)
+    elif storage_type == "hdf":
+        write_legacy_hdf(output_dir=output_dir, format="fixed")
+        write_legacy_hdf(output_dir=output_dir, format="table")
+    else:
+        sys.exit("storage_type must be one of {'pickle', 'hdf'}")
+
+
+if __name__ == "__main__":
+    write_legacy_file()

.venv/lib/python3.13/site-packages/pandas/tests/io/json/conftest.py

@@ -0,0 +1,9 @@
+import pytest
+
+
+@pytest.fixture(params=["split", "records", "index", "columns", "values"])
+def orient(request):
+    """
+    Fixture for orients excluding the table format.
+    """
+    return request.param

.venv/lib/python3.13/site-packages/pandas/tests/io/json/test_compression.py

@@ -0,0 +1,130 @@
+from io import (
+    BytesIO,
+    StringIO,
+)
+import uuid
+
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_compression_roundtrip(compression, temp_file):
+    df = pd.DataFrame(
+        [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+        index=["A", "B"],
+        columns=["X", "Y", "Z"],
+    )
+
+    df.to_json(temp_file, compression=compression)
+    tm.assert_frame_equal(df, pd.read_json(temp_file, compression=compression))
+
+    # explicitly ensure file was compressed.
+    with tm.decompress_file(temp_file, compression) as fh:
+        result = fh.read().decode("utf8")
+        data = StringIO(result)
+    tm.assert_frame_equal(df, pd.read_json(data))
+
+
+def test_read_zipped_json(datapath):
+    uncompressed_path = datapath("io", "json", "data", "tsframe_v012.json")
+    uncompressed_df = pd.read_json(uncompressed_path)
+
+    compressed_path = datapath("io", "json", "data", "tsframe_v012.json.zip")
+    compressed_df = pd.read_json(compressed_path, compression="zip")
+
+    tm.assert_frame_equal(uncompressed_df, compressed_df)
+
+
+@td.skip_if_not_us_locale
+@pytest.mark.single_cpu
+@pytest.mark.network
+def test_with_s3_url(compression, s3_bucket_public, s3so, temp_file):
+    # Bucket created in tests/io/conftest.py
+    df = pd.read_json(StringIO('{"a": [1, 2, 3], "b": [4, 5, 6]}'))
+
+    key = f"{uuid.uuid4()}.json"
+    df.to_json(temp_file, compression=compression)
+    with open(temp_file, "rb") as f:
+        s3_bucket_public.put_object(Key=key, Body=f)
+
+    roundtripped_df = pd.read_json(
+        f"s3://{s3_bucket_public.name}/{key}",
+        compression=compression,
+        storage_options=s3so,
+    )
+    tm.assert_frame_equal(df, roundtripped_df)
+
+
+def test_lines_with_compression(compression, temp_file):
+    df = pd.read_json(StringIO('{"a": [1, 2, 3], "b": [4, 5, 6]}'))
+    df.to_json(temp_file, orient="records", lines=True, compression=compression)
+    roundtripped_df = pd.read_json(temp_file, lines=True, compression=compression)
+    tm.assert_frame_equal(df, roundtripped_df)
+
+
+def test_chunksize_with_compression(compression, temp_file):
+    df = pd.read_json(StringIO('{"a": ["foo", "bar", "baz"], "b": [4, 5, 6]}'))
+    df.to_json(temp_file, orient="records", lines=True, compression=compression)
+
+    with pd.read_json(
+        temp_file, lines=True, chunksize=1, compression=compression
+    ) as res:
+        roundtripped_df = pd.concat(res)
+    tm.assert_frame_equal(df, roundtripped_df)
+
+
+def test_write_unsupported_compression_type(temp_file):
+    df = pd.read_json(StringIO('{"a": [1, 2, 3], "b": [4, 5, 6]}'))
+    msg = "Unrecognized compression type: unsupported"
+    with pytest.raises(ValueError, match=msg):
+        df.to_json(temp_file, compression="unsupported")
+
+
+def test_read_unsupported_compression_type(temp_file):
+    msg = "Unrecognized compression type: unsupported"
+    with pytest.raises(ValueError, match=msg):
+        pd.read_json(temp_file, compression="unsupported")
+
+
+@pytest.mark.parametrize(
+    "infer_string", [False, pytest.param(True, marks=td.skip_if_no("pyarrow"))]
+)
+@pytest.mark.parametrize("to_infer", [True, False])
+@pytest.mark.parametrize("read_infer", [True, False])
+def test_to_json_compression(
+    compression_only,
+    read_infer,
+    to_infer,
+    compression_to_extension,
+    infer_string,
+    tmp_path,
+):
+    with pd.option_context("future.infer_string", infer_string):
+        # see gh-15008
+        compression = compression_only
+
+        # We'll complete file extension subsequently.
+        filename = tmp_path / f"test.{compression_to_extension[compression]}"
+
+        df = pd.DataFrame({"A": [1]})
+
+        to_compression = "infer" if to_infer else compression
+        read_compression = "infer" if read_infer else compression
+
+        df.to_json(filename, compression=to_compression)
+        result = pd.read_json(filename, compression=read_compression)
+        tm.assert_frame_equal(result, df)
+
+
+def test_to_json_compression_mode(compression):
+    # GH 39985 (read_json does not support user-provided binary files)
+    expected = pd.DataFrame({"A": [1]})
+
+    with BytesIO() as buffer:
+        expected.to_json(buffer, compression=compression)
+        # df = pd.read_json(buffer, compression=compression)
+        # tm.assert_frame_equal(expected, df)

.venv/lib/python3.13/site-packages/pandas/tests/io/json/test_deprecated_kwargs.py

@@ -0,0 +1,22 @@
+"""
+Tests for the deprecated keyword arguments for `read_json`.
+"""
+
+from io import StringIO
+
+import pandas as pd
+import pandas._testing as tm
+
+from pandas.io.json import read_json
+
+
+def test_good_kwargs():
+    df = pd.DataFrame({"A": [2, 4, 6], "B": [3, 6, 9]}, index=[0, 1, 2])
+
+    with tm.assert_produces_warning(None):
+        data1 = StringIO(df.to_json(orient="split"))
+        tm.assert_frame_equal(df, read_json(data1, orient="split"))
+        data2 = StringIO(df.to_json(orient="columns"))
+        tm.assert_frame_equal(df, read_json(data2, orient="columns"))
+        data3 = StringIO(df.to_json(orient="index"))
+        tm.assert_frame_equal(df, read_json(data3, orient="index"))

.venv/lib/python3.13/site-packages/pandas/tests/io/json/test_json_table_schema.py

@@ -0,0 +1,898 @@
+"""Tests for Table Schema integration."""
+
+from collections import OrderedDict
+from io import StringIO
+import json
+
+import numpy as np
+import pytest
+
+from pandas.errors import Pandas4Warning
+
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    DatetimeTZDtype,
+    PeriodDtype,
+)
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+
+from pandas.io.json._table_schema import (
+    as_json_table_type,
+    build_table_schema,
+    convert_json_field_to_pandas_type,
+    convert_pandas_type_to_json_field,
+    set_default_names,
+)
+
+
+@pytest.fixture
+def df_schema():
+    return DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "c"],
+            "C": pd.date_range("2016-01-01", freq="D", periods=4),
+            "D": pd.timedelta_range("1h", periods=4, freq="min"),
+        },
+        index=pd.Index(range(4), name="idx"),
+    )
+
+
+@pytest.fixture
+def df_table():
+    return DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "c"],
+            "C": pd.date_range("2016-01-01", freq="D", periods=4),
+            "D": pd.timedelta_range("1h", periods=4, freq="min"),
+            "E": pd.Series(pd.Categorical(["a", "b", "c", "c"])),
+            "F": pd.Series(pd.Categorical(["a", "b", "c", "c"], ordered=True)),
+            "G": [1.0, 2.0, 3, 4.0],
+            "H": pd.date_range("2016-01-01", freq="D", periods=4, tz="US/Central"),
+        },
+        index=pd.Index(range(4), name="idx"),
+    )
+
+
+class TestBuildSchema:
+    def test_build_table_schema(self, df_schema, using_infer_string):
+        result = build_table_schema(df_schema, version=False)
+        expected = {
+            "fields": [
+                {"name": "idx", "type": "integer"},
+                {"name": "A", "type": "integer"},
+                {"name": "B", "type": "string"},
+                {"name": "C", "type": "datetime"},
+                {"name": "D", "type": "duration"},
+            ],
+            "primaryKey": ["idx"],
+        }
+        if using_infer_string:
+            expected["fields"][2] = {"name": "B", "type": "string", "extDtype": "str"}
+        assert result == expected
+        result = build_table_schema(df_schema)
+        assert "pandas_version" in result
+
+    def test_series(self):
+        s = pd.Series([1, 2, 3], name="foo")
+        result = build_table_schema(s, version=False)
+        expected = {
+            "fields": [
+                {"name": "index", "type": "integer"},
+                {"name": "foo", "type": "integer"},
+            ],
+            "primaryKey": ["index"],
+        }
+        assert result == expected
+        result = build_table_schema(s)
+        assert "pandas_version" in result
+
+    def test_series_unnamed(self):
+        result = build_table_schema(pd.Series([1, 2, 3]), version=False)
+        expected = {
+            "fields": [
+                {"name": "index", "type": "integer"},
+                {"name": "values", "type": "integer"},
+            ],
+            "primaryKey": ["index"],
+        }
+        assert result == expected
+
+    def test_multiindex(self, df_schema, using_infer_string):
+        df = df_schema
+        idx = pd.MultiIndex.from_product([("a", "b"), (1, 2)])
+        df.index = idx
+
+        result = build_table_schema(df, version=False)
+        expected = {
+            "fields": [
+                {"name": "level_0", "type": "string"},
+                {"name": "level_1", "type": "integer"},
+                {"name": "A", "type": "integer"},
+                {"name": "B", "type": "string"},
+                {"name": "C", "type": "datetime"},
+                {"name": "D", "type": "duration"},
+            ],
+            "primaryKey": ["level_0", "level_1"],
+        }
+        if using_infer_string:
+            expected["fields"][0] = {
+                "name": "level_0",
+                "type": "string",
+                "extDtype": "str",
+            }
+            expected["fields"][3] = {"name": "B", "type": "string", "extDtype": "str"}
+        assert result == expected
+
+        df.index.names = ["idx0", None]
+        expected["fields"][0]["name"] = "idx0"
+        expected["primaryKey"] = ["idx0", "level_1"]
+        result = build_table_schema(df, version=False)
+        assert result == expected
+
+
+class TestTableSchemaType:
+    @pytest.mark.parametrize("int_type", [int, np.int16, np.int32, np.int64])
+    def test_as_json_table_type_int_data(self, int_type):
+        int_data = [1, 2, 3]
+        assert as_json_table_type(np.array(int_data, dtype=int_type).dtype) == "integer"
+
+    @pytest.mark.parametrize("float_type", [float, np.float16, np.float32, np.float64])
+    def test_as_json_table_type_float_data(self, float_type):
+        float_data = [1.0, 2.0, 3.0]
+        assert (
+            as_json_table_type(np.array(float_data, dtype=float_type).dtype) == "number"
+        )
+
+    @pytest.mark.parametrize("bool_type", [bool, np.bool_])
+    def test_as_json_table_type_bool_data(self, bool_type):
+        bool_data = [True, False]
+        assert (
+            as_json_table_type(np.array(bool_data, dtype=bool_type).dtype) == "boolean"
+        )
+
+    @pytest.mark.parametrize(
+        "date_data",
+        [
+            pd.to_datetime(["2016"]),
+            pd.to_datetime(["2016"], utc=True),
+            pd.Series(pd.to_datetime(["2016"])),
+            pd.Series(pd.to_datetime(["2016"], utc=True)),
+            pd.period_range("2016", freq="Y", periods=3),
+        ],
+    )
+    def test_as_json_table_type_date_data(self, date_data):
+        assert as_json_table_type(date_data.dtype) == "datetime"
+
+    @pytest.mark.parametrize("klass", [pd.Series, pd.Index])
+    def test_as_json_table_type_string_data(self, klass):
+        str_data = klass(["a", "b"], dtype=object)
+        assert as_json_table_type(str_data.dtype) == "string"
+
+    @pytest.mark.parametrize(
+        "cat_data",
+        [
+            pd.Categorical(["a"]),
+            pd.Categorical([1]),
+            pd.Series(pd.Categorical([1])),
+            pd.CategoricalIndex([1]),
+        ],
+    )
+    def test_as_json_table_type_categorical_data(self, cat_data):
+        assert as_json_table_type(cat_data.dtype) == "any"
+
+    # ------
+    # dtypes
+    # ------
+    @pytest.mark.parametrize("int_dtype", [int, np.int16, np.int32, np.int64])
+    def test_as_json_table_type_int_dtypes(self, int_dtype):
+        assert as_json_table_type(int_dtype) == "integer"
+
+    @pytest.mark.parametrize("float_dtype", [float, np.float16, np.float32, np.float64])
+    def test_as_json_table_type_float_dtypes(self, float_dtype):
+        assert as_json_table_type(float_dtype) == "number"
+
+    @pytest.mark.parametrize("bool_dtype", [bool, np.bool_])
+    def test_as_json_table_type_bool_dtypes(self, bool_dtype):
+        assert as_json_table_type(bool_dtype) == "boolean"
+
+    @pytest.mark.parametrize(
+        "date_dtype",
+        [
+            np.dtype("<M8[ns]"),
+            PeriodDtype("D"),
+            DatetimeTZDtype("ns", "US/Central"),
+        ],
+    )
+    def test_as_json_table_type_date_dtypes(self, date_dtype):
+        # TODO: datedate.date? datetime.time?
+        assert as_json_table_type(date_dtype) == "datetime"
+
+    @pytest.mark.parametrize("td_dtype", [np.dtype("<m8[ns]")])
+    def test_as_json_table_type_timedelta_dtypes(self, td_dtype):
+        assert as_json_table_type(td_dtype) == "duration"
+
+    @pytest.mark.parametrize("str_dtype", [object])  # TODO(GH#14904) flesh out dtypes?
+    def test_as_json_table_type_string_dtypes(self, str_dtype):
+        assert as_json_table_type(str_dtype) == "string"
+
+    def test_as_json_table_type_categorical_dtypes(self):
+        assert as_json_table_type(pd.Categorical(["a"]).dtype) == "any"
+        assert as_json_table_type(CategoricalDtype()) == "any"
+
+
+class TestTableOrient:
+    def test_build_series(self):
+        s = pd.Series([1, 2], name="a")
+        s.index.name = "id"
+        result = s.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+
+        assert "pandas_version" in result["schema"]
+        result["schema"].pop("pandas_version")
+
+        fields = [{"name": "id", "type": "integer"}, {"name": "a", "type": "integer"}]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                (
+                    "data",
+                    [
+                        OrderedDict([("id", 0), ("a", 1)]),
+                        OrderedDict([("id", 1), ("a", 2)]),
+                    ],
+                ),
+            ]
+        )
+
+        assert result == expected
+
+    def test_read_json_from_to_json_results(self):
+        # GH32383
+        df = DataFrame(
+            {
+                "_id": {"row_0": 0},
+                "category": {"row_0": "Goods"},
+                "recommender_id": {"row_0": 3},
+                "recommender_name_jp": {"row_0": "浦田"},
+                "recommender_name_en": {"row_0": "Urata"},
+                "name_jp": {"row_0": "博多人形(松尾吉将まつお よしまさ)"},
+                "name_en": {"row_0": "Hakata Dolls Matsuo"},
+            }
+        )
+
+        result1 = pd.read_json(StringIO(df.to_json()))
+        result2 = DataFrame.from_dict(json.loads(df.to_json()))
+        tm.assert_frame_equal(result1, df)
+        tm.assert_frame_equal(result2, df)
+
+    def test_to_json(self, df_table, using_infer_string):
+        df = df_table
+        df.index.name = "idx"
+        result = df.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+
+        assert "pandas_version" in result["schema"]
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"name": "idx", "type": "integer"},
+            {"name": "A", "type": "integer"},
+            {"name": "B", "type": "string"},
+            {"name": "C", "type": "datetime"},
+            {"name": "D", "type": "duration"},
+            {
+                "constraints": {"enum": ["a", "b", "c"]},
+                "name": "E",
+                "ordered": False,
+                "type": "any",
+            },
+            {
+                "constraints": {"enum": ["a", "b", "c"]},
+                "name": "F",
+                "ordered": True,
+                "type": "any",
+            },
+            {"name": "G", "type": "number"},
+            {"name": "H", "type": "datetime", "tz": "US/Central"},
+        ]
+
+        if using_infer_string:
+            fields[2] = {"name": "B", "type": "string", "extDtype": "str"}
+
+        schema = {"fields": fields, "primaryKey": ["idx"]}
+        data = [
+            OrderedDict(
+                [
+                    ("idx", 0),
+                    ("A", 1),
+                    ("B", "a"),
+                    ("C", "2016-01-01T00:00:00.000"),
+                    ("D", "P0DT1H0M0S"),
+                    ("E", "a"),
+                    ("F", "a"),
+                    ("G", 1.0),
+                    ("H", "2016-01-01T06:00:00.000Z"),
+                ]
+            ),
+            OrderedDict(
+                [
+                    ("idx", 1),
+                    ("A", 2),
+                    ("B", "b"),
+                    ("C", "2016-01-02T00:00:00.000"),
+                    ("D", "P0DT1H1M0S"),
+                    ("E", "b"),
+                    ("F", "b"),
+                    ("G", 2.0),
+                    ("H", "2016-01-02T06:00:00.000Z"),
+                ]
+            ),
+            OrderedDict(
+                [
+                    ("idx", 2),
+                    ("A", 3),
+                    ("B", "c"),
+                    ("C", "2016-01-03T00:00:00.000"),
+                    ("D", "P0DT1H2M0S"),
+                    ("E", "c"),
+                    ("F", "c"),
+                    ("G", 3.0),
+                    ("H", "2016-01-03T06:00:00.000Z"),
+                ]
+            ),
+            OrderedDict(
+                [
+                    ("idx", 3),
+                    ("A", 4),
+                    ("B", "c"),
+                    ("C", "2016-01-04T00:00:00.000"),
+                    ("D", "P0DT1H3M0S"),
+                    ("E", "c"),
+                    ("F", "c"),
+                    ("G", 4.0),
+                    ("H", "2016-01-04T06:00:00.000Z"),
+                ]
+            ),
+        ]
+        expected = OrderedDict([("schema", schema), ("data", data)])
+
+        assert result == expected
+
+    def test_to_json_float_index(self):
+        data = pd.Series(1, index=[1.0, 2.0])
+        result = data.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+        result["schema"].pop("pandas_version")
+
+        expected = OrderedDict(
+            [
+                (
+                    "schema",
+                    {
+                        "fields": [
+                            {"name": "index", "type": "number"},
+                            {"name": "values", "type": "integer"},
+                        ],
+                        "primaryKey": ["index"],
+                    },
+                ),
+                (
+                    "data",
+                    [
+                        OrderedDict([("index", 1.0), ("values", 1)]),
+                        OrderedDict([("index", 2.0), ("values", 1)]),
+                    ],
+                ),
+            ]
+        )
+
+        assert result == expected
+
+    def test_to_json_period_index(self):
+        idx = pd.period_range("2016", freq="Q-JAN", periods=2)
+        data = pd.Series(1, idx)
+        result = data.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"freq": "QE-JAN", "name": "index", "type": "datetime"},
+            {"name": "values", "type": "integer"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["index"]}
+        data = [
+            OrderedDict([("index", "2015-11-01T00:00:00.000"), ("values", 1)]),
+            OrderedDict([("index", "2016-02-01T00:00:00.000"), ("values", 1)]),
+        ]
+        expected = OrderedDict([("schema", schema), ("data", data)])
+
+        assert result == expected
+
+    def test_to_json_categorical_index(self):
+        data = pd.Series(1, pd.CategoricalIndex(["a", "b"]))
+        result = data.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+        result["schema"].pop("pandas_version")
+
+        expected = OrderedDict(
+            [
+                (
+                    "schema",
+                    {
+                        "fields": [
+                            {
+                                "name": "index",
+                                "type": "any",
+                                "constraints": {"enum": ["a", "b"]},
+                                "ordered": False,
+                            },
+                            {"name": "values", "type": "integer"},
+                        ],
+                        "primaryKey": ["index"],
+                    },
+                ),
+                (
+                    "data",
+                    [
+                        OrderedDict([("index", "a"), ("values", 1)]),
+                        OrderedDict([("index", "b"), ("values", 1)]),
+                    ],
+                ),
+            ]
+        )
+
+        assert result == expected
+
+    def test_date_format_raises(self, df_table):
+        error_msg = (
+            "Trying to write with `orient='table'` and `date_format='epoch'`. Table "
+            "Schema requires dates to be formatted with `date_format='iso'`"
+        )
+        warning_msg = (
+            "'epoch' date format is deprecated and will be removed in a future "
+            "version, please use 'iso' date format instead."
+        )
+        with pytest.raises(ValueError, match=error_msg):
+            with tm.assert_produces_warning(Pandas4Warning, match=warning_msg):
+                df_table.to_json(orient="table", date_format="epoch")
+
+        # others work
+        df_table.to_json(orient="table", date_format="iso")
+        df_table.to_json(orient="table")
+
+    def test_convert_pandas_type_to_json_field_int(self, index_or_series):
+        kind = index_or_series
+        data = [1, 2, 3]
+        result = convert_pandas_type_to_json_field(kind(data, name="name"))
+        expected = {"name": "name", "type": "integer"}
+        assert result == expected
+
+    def test_convert_pandas_type_to_json_field_float(self, index_or_series):
+        kind = index_or_series
+        data = [1.0, 2.0, 3.0]
+        result = convert_pandas_type_to_json_field(kind(data, name="name"))
+        expected = {"name": "name", "type": "number"}
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "dt_args,extra_exp", [({}, {}), ({"utc": True}, {"tz": "UTC"})]
+    )
+    @pytest.mark.parametrize("wrapper", [None, pd.Series])
+    def test_convert_pandas_type_to_json_field_datetime(
+        self, dt_args, extra_exp, wrapper
+    ):
+        data = [1.0, 2.0, 3.0]
+        data = pd.to_datetime(data, **dt_args)
+        if wrapper is pd.Series:
+            data = pd.Series(data, name="values")
+        result = convert_pandas_type_to_json_field(data)
+        expected = {"name": "values", "type": "datetime"}
+        expected.update(extra_exp)
+        assert result == expected
+
+    def test_convert_pandas_type_to_json_period_range(self):
+        arr = pd.period_range("2016", freq="Y-DEC", periods=4)
+        result = convert_pandas_type_to_json_field(arr)
+        expected = {"name": "values", "type": "datetime", "freq": "YE-DEC"}
+        assert result == expected
+
+    @pytest.mark.parametrize("kind", [pd.Categorical, pd.CategoricalIndex])
+    @pytest.mark.parametrize("ordered", [True, False])
+    def test_convert_pandas_type_to_json_field_categorical(self, kind, ordered):
+        data = ["a", "b", "c"]
+        if kind is pd.Categorical:
+            arr = pd.Series(kind(data, ordered=ordered), name="cats")
+        elif kind is pd.CategoricalIndex:
+            arr = kind(data, ordered=ordered, name="cats")
+
+        result = convert_pandas_type_to_json_field(arr)
+        expected = {
+            "name": "cats",
+            "type": "any",
+            "constraints": {"enum": data},
+            "ordered": ordered,
+        }
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "inp,exp",
+        [
+            ({"type": "integer"}, "int64"),
+            ({"type": "number"}, "float64"),
+            ({"type": "boolean"}, "bool"),
+            ({"type": "duration"}, "timedelta64"),
+            ({"type": "datetime"}, "datetime64[ns]"),
+            ({"type": "datetime", "tz": "US/Hawaii"}, "datetime64[ns, US/Hawaii]"),
+            ({"type": "any"}, "object"),
+            (
+                {
+                    "type": "any",
+                    "constraints": {"enum": ["a", "b", "c"]},
+                    "ordered": False,
+                },
+                CategoricalDtype(categories=["a", "b", "c"], ordered=False),
+            ),
+            (
+                {
+                    "type": "any",
+                    "constraints": {"enum": ["a", "b", "c"]},
+                    "ordered": True,
+                },
+                CategoricalDtype(categories=["a", "b", "c"], ordered=True),
+            ),
+            ({"type": "string"}, None),
+        ],
+    )
+    def test_convert_json_field_to_pandas_type(self, inp, exp):
+        field = {"name": "foo"}
+        field.update(inp)
+        assert convert_json_field_to_pandas_type(field) == exp
+
+    @pytest.mark.parametrize("inp", ["geopoint", "geojson", "fake_type"])
+    def test_convert_json_field_to_pandas_type_raises(self, inp):
+        field = {"type": inp}
+        with pytest.raises(
+            ValueError, match=f"Unsupported or invalid field type: {inp}"
+        ):
+            convert_json_field_to_pandas_type(field)
+
+    def test_categorical(self):
+        s = pd.Series(pd.Categorical(["a", "b", "a"]))
+        s.index.name = "idx"
+        result = s.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"name": "idx", "type": "integer"},
+            {
+                "constraints": {"enum": ["a", "b"]},
+                "name": "values",
+                "ordered": False,
+                "type": "any",
+            },
+        ]
+
+        expected = OrderedDict(
+            [
+                ("schema", {"fields": fields, "primaryKey": ["idx"]}),
+                (
+                    "data",
+                    [
+                        OrderedDict([("idx", 0), ("values", "a")]),
+                        OrderedDict([("idx", 1), ("values", "b")]),
+                        OrderedDict([("idx", 2), ("values", "a")]),
+                    ],
+                ),
+            ]
+        )
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "idx,nm,prop",
+        [
+            (pd.Index([1]), "index", "name"),
+            (pd.Index([1], name="myname"), "myname", "name"),
+            (
+                pd.MultiIndex.from_product([("a", "b"), ("c", "d")]),
+                ["level_0", "level_1"],
+                "names",
+            ),
+            (
+                pd.MultiIndex.from_product(
+                    [("a", "b"), ("c", "d")], names=["n1", "n2"]
+                ),
+                ["n1", "n2"],
+                "names",
+            ),
+            (
+                pd.MultiIndex.from_product(
+                    [("a", "b"), ("c", "d")], names=["n1", None]
+                ),
+                ["n1", "level_1"],
+                "names",
+            ),
+        ],
+    )
+    def test_set_names_unset(self, idx, nm, prop):
+        data = pd.Series(1, idx)
+        result = set_default_names(data)
+        assert getattr(result.index, prop) == nm
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            pd.Index([], name="index"),
+            pd.MultiIndex.from_arrays([["foo"], ["bar"]], names=("level_0", "level_1")),
+            pd.MultiIndex.from_arrays([["foo"], ["bar"]], names=("foo", "level_1")),
+        ],
+    )
+    def test_warns_non_roundtrippable_names(self, idx):
+        # GH 19130
+        df = DataFrame(index=idx)
+        df.index.name = "index"
+        with tm.assert_produces_warning(UserWarning, match="not round-trippable"):
+            set_default_names(df)
+
+    def test_timestamp_in_columns(self):
+        df = DataFrame(
+            [[1, 2]], columns=[pd.Timestamp("2016"), pd.Timedelta(10, unit="s")]
+        )
+        result = df.to_json(orient="table")
+        js = json.loads(result)
+        assert js["schema"]["fields"][1]["name"] == "2016-01-01T00:00:00.000"
+        assert js["schema"]["fields"][2]["name"] == "P0DT0H0M10S"
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            pd.Series([1], index=pd.Index([1], name="a"), name="a"),
+            DataFrame({"A": [1]}, index=pd.Index([1], name="A")),
+            DataFrame(
+                {"A": [1]},
+                index=pd.MultiIndex.from_arrays([["a"], [1]], names=["A", "a"]),
+            ),
+        ],
+    )
+    def test_overlapping_names(self, case):
+        with pytest.raises(ValueError, match="Overlapping"):
+            case.to_json(orient="table")
+
+    def test_mi_falsey_name(self):
+        # GH 16203
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)),
+            index=pd.MultiIndex.from_product([("A", "B"), ("a", "b")]),
+        )
+        result = [x["name"] for x in build_table_schema(df)["fields"]]
+        assert result == ["level_0", "level_1", 0, 1, 2, 3]
+
+
+class TestTableOrientReader:
+    @pytest.mark.parametrize(
+        "index_nm",
+        [None, "idx", pytest.param("index", marks=pytest.mark.xfail), "level_0"],
+    )
+    @pytest.mark.parametrize(
+        "vals",
+        [
+            {"ints": [1, 2, 3, 4]},
+            {"objects": ["a", "b", "c", "d"]},
+            {"objects": ["1", "2", "3", "4"]},
+            {
+                "date_ranges": pd.date_range(
+                    "2016-01-01", freq="D", periods=4, unit="ns"
+                )
+            },
+            {"categoricals": pd.Series(pd.Categorical(["a", "b", "c", "c"]))},
+            {
+                "ordered_cats": pd.Series(
+                    pd.Categorical(["a", "b", "c", "c"], ordered=True)
+                )
+            },
+            {"floats": [1.0, 2.0, 3.0, 4.0]},
+            {"floats": [1.1, 2.2, 3.3, 4.4]},
+            {"bools": [True, False, False, True]},
+            {
+                "timezones": pd.date_range(
+                    "2016-01-01", freq="D", periods=4, tz="US/Central", unit="ns"
+                )  # added in # GH 35973
+            },
+        ],
+    )
+    def test_read_json_table_orient(self, index_nm, vals):
+        df = DataFrame(vals, index=pd.Index(range(4), name=index_nm))
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    @pytest.mark.parametrize(
+        "index_nm",
+        [
+            None,
+            "idx",
+            pytest.param(
+                "index",
+                marks=pytest.mark.filterwarnings("ignore:Index name:UserWarning"),
+            ),
+        ],
+    )
+    def test_read_json_table_orient_raises(self, index_nm):
+        vals = {"timedeltas": pd.timedelta_range("1h", periods=4, freq="min")}
+        df = DataFrame(vals, index=pd.Index(range(4), name=index_nm))
+        out = StringIO(df.to_json(orient="table"))
+        with pytest.raises(NotImplementedError, match="can not yet read "):
+            pd.read_json(out, orient="table")
+
+    @pytest.mark.parametrize(
+        "index_nm",
+        [None, "idx", pytest.param("index", marks=pytest.mark.xfail), "level_0"],
+    )
+    @pytest.mark.parametrize(
+        "vals",
+        [
+            {"ints": [1, 2, 3, 4]},
+            {"objects": ["a", "b", "c", "d"]},
+            {"objects": ["1", "2", "3", "4"]},
+            {
+                "date_ranges": pd.date_range(
+                    "2016-01-01", freq="D", periods=4, unit="ns"
+                )
+            },
+            {"categoricals": pd.Series(pd.Categorical(["a", "b", "c", "c"]))},
+            {
+                "ordered_cats": pd.Series(
+                    pd.Categorical(["a", "b", "c", "c"], ordered=True)
+                )
+            },
+            {"floats": [1.0, 2.0, 3.0, 4.0]},
+            {"floats": [1.1, 2.2, 3.3, 4.4]},
+            {"bools": [True, False, False, True]},
+            {
+                "timezones": pd.date_range(
+                    "2016-01-01", freq="D", periods=4, tz="US/Central", unit="ns"
+                )  # added in # GH 35973
+            },
+        ],
+    )
+    def test_read_json_table_period_orient(self, index_nm, vals):
+        df = DataFrame(
+            vals,
+            index=pd.Index(
+                (pd.Period(f"2022Q{q}") for q in range(1, 5)), name=index_nm
+            ),
+        )
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            pd.Index(range(4)),
+            pd.date_range(
+                "2020-08-30",
+                freq="D",
+                periods=4,
+                unit="ns",
+            )._with_freq(None),
+            pd.date_range(
+                "2020-08-30", freq="D", periods=4, tz="US/Central", unit="ns"
+            )._with_freq(None),
+            pd.MultiIndex.from_product(
+                [
+                    pd.date_range(
+                        "2020-08-30", freq="D", periods=2, tz="US/Central", unit="ns"
+                    ),
+                    ["x", "y"],
+                ],
+            ),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "vals",
+        [
+            {"floats": [1.1, 2.2, 3.3, 4.4]},
+            {"dates": pd.date_range("2020-08-30", freq="D", periods=4, unit="ns")},
+            {
+                "timezones": pd.date_range(
+                    "2020-08-30", freq="D", periods=4, tz="Europe/London", unit="ns"
+                )
+            },
+        ],
+    )
+    def test_read_json_table_timezones_orient(self, idx, vals):
+        # GH 35973
+        df = DataFrame(vals, index=idx)
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    def test_comprehensive(self):
+        df = DataFrame(
+            {
+                "A": [1, 2, 3, 4],
+                "B": ["a", "b", "c", "c"],
+                "C": pd.date_range("2016-01-01", freq="D", periods=4, unit="ns"),
+                # 'D': pd.timedelta_range('1h', periods=4, freq='min'),
+                "E": pd.Series(pd.Categorical(["a", "b", "c", "c"])),
+                "F": pd.Series(pd.Categorical(["a", "b", "c", "c"], ordered=True)),
+                "G": [1.1, 2.2, 3.3, 4.4],
+                "H": pd.date_range(
+                    "2016-01-01", freq="D", periods=4, tz="US/Central", unit="ns"
+                ),
+                "I": [True, False, False, True],
+            },
+            index=pd.Index(range(4), name="idx"),
+        )
+
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    @pytest.mark.parametrize(
+        "index_names",
+        [[None, None], ["foo", "bar"], ["foo", None], [None, "foo"], ["index", "foo"]],
+    )
+    def test_multiindex(self, index_names):
+        # GH 18912
+        df = DataFrame(
+            [["Arr", "alpha", [1, 2, 3, 4]], ["Bee", "Beta", [10, 20, 30, 40]]],
+            index=[["A", "B"], ["Null", "Eins"]],
+            columns=["Aussprache", "Griechisch", "Args"],
+        )
+        df.index.names = index_names
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    def test_empty_frame_roundtrip(self):
+        # GH 21287
+        df = DataFrame(columns=["a", "b", "c"])
+        expected = df.copy()
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(expected, result)
+
+    def test_read_json_orient_table_old_schema_version(self):
+        df_json = """
+        {
+            "schema":{
+                "fields":[
+                    {"name":"index","type":"integer"},
+                    {"name":"a","type":"string"}
+                ],
+                "primaryKey":["index"],
+                "pandas_version":"0.20.0"
+            },
+            "data":[
+                {"index":0,"a":1},
+                {"index":1,"a":2.0},
+                {"index":2,"a":"s"}
+            ]
+        }
+        """
+        expected = DataFrame({"a": [1, 2.0, "s"]})
+        result = pd.read_json(StringIO(df_json), orient="table")
+        tm.assert_frame_equal(expected, result)
+
+    @pytest.mark.parametrize("freq", ["M", "2M", "Q", "2Q", "Y", "2Y"])
+    def test_read_json_table_orient_period_depr_freq(self, freq):
+        # GH#9586
+        df = DataFrame(
+            {"ints": [1, 2]},
+            index=pd.PeriodIndex(["2020-01", "2021-06"], freq=freq),
+        )
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)

.venv/lib/python3.13/site-packages/pandas/tests/io/json/test_json_table_schema_ext_dtype.py

@@ -0,0 +1,296 @@
+"""Tests for ExtensionDtype Table Schema integration."""
+
+from collections import OrderedDict
+import datetime as dt
+import decimal
+from io import StringIO
+import json
+
+import pytest
+
+from pandas import (
+    NA,
+    DataFrame,
+    Index,
+    array,
+    read_json,
+)
+import pandas._testing as tm
+from pandas.core.arrays.integer import Int64Dtype
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.series import Series
+from pandas.tests.extension.date import (
+    DateArray,
+    DateDtype,
+)
+from pandas.tests.extension.decimal.array import (
+    DecimalArray,
+    DecimalDtype,
+)
+
+from pandas.io.json._table_schema import (
+    as_json_table_type,
+    build_table_schema,
+)
+
+
+class TestBuildSchema:
+    def test_build_table_schema(self):
+        df = DataFrame(
+            {
+                "A": DateArray([dt.date(2021, 10, 10)]),
+                "B": DecimalArray([decimal.Decimal(10)]),
+                "C": array(["pandas"], dtype="string"),
+                "D": array([10], dtype="Int64"),
+            }
+        )
+        result = build_table_schema(df, version=False)
+        expected = {
+            "fields": [
+                {"name": "index", "type": "integer"},
+                {"name": "A", "type": "any", "extDtype": "DateDtype"},
+                {"name": "B", "type": "number", "extDtype": "decimal"},
+                {"name": "C", "type": "string", "extDtype": "string"},
+                {"name": "D", "type": "integer", "extDtype": "Int64"},
+            ],
+            "primaryKey": ["index"],
+        }
+        assert result == expected
+        result = build_table_schema(df)
+        assert "pandas_version" in result
+
+
+class TestTableSchemaType:
+    @pytest.mark.parametrize("box", [lambda x: x, Series])
+    def test_as_json_table_type_ext_date_array_dtype(self, box):
+        date_data = box(DateArray([dt.date(2021, 10, 10)]))
+        assert as_json_table_type(date_data.dtype) == "any"
+
+    def test_as_json_table_type_ext_date_dtype(self):
+        assert as_json_table_type(DateDtype()) == "any"
+
+    @pytest.mark.parametrize("box", [lambda x: x, Series])
+    def test_as_json_table_type_ext_decimal_array_dtype(self, box):
+        decimal_data = box(DecimalArray([decimal.Decimal(10)]))
+        assert as_json_table_type(decimal_data.dtype) == "number"
+
+    def test_as_json_table_type_ext_decimal_dtype(self):
+        assert as_json_table_type(DecimalDtype()) == "number"
+
+    @pytest.mark.parametrize("box", [lambda x: x, Series])
+    def test_as_json_table_type_ext_string_array_dtype(self, box):
+        string_data = box(array(["pandas"], dtype="string"))
+        assert as_json_table_type(string_data.dtype) == "string"
+
+    def test_as_json_table_type_ext_string_dtype(self):
+        assert as_json_table_type(StringDtype()) == "string"
+
+    @pytest.mark.parametrize("box", [lambda x: x, Series])
+    def test_as_json_table_type_ext_integer_array_dtype(self, box):
+        integer_data = box(array([10], dtype="Int64"))
+        assert as_json_table_type(integer_data.dtype) == "integer"
+
+    def test_as_json_table_type_ext_integer_dtype(self):
+        assert as_json_table_type(Int64Dtype()) == "integer"
+
+
+class TestTableOrient:
+    @pytest.fixture
+    def da(self):
+        """Fixture for creating a DateArray."""
+        return DateArray([dt.date(2021, 10, 10)])
+
+    @pytest.fixture
+    def dc(self):
+        """Fixture for creating a DecimalArray."""
+        return DecimalArray([decimal.Decimal(10)])
+
+    @pytest.fixture
+    def sa(self):
+        """Fixture for creating a StringDtype array."""
+        return array(["pandas"], dtype="string")
+
+    @pytest.fixture
+    def ia(self):
+        """Fixture for creating an Int64Dtype array."""
+        return array([10], dtype="Int64")
+
+    def test_build_date_series(self, da):
+        s = Series(da, name="a")
+        s.index.name = "id"
+        result = s.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+
+        assert "pandas_version" in result["schema"]
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"name": "id", "type": "integer"},
+            {"name": "a", "type": "any", "extDtype": "DateDtype"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                ("data", [OrderedDict([("id", 0), ("a", "2021-10-10T00:00:00.000")])]),
+            ]
+        )
+
+        assert result == expected
+
+    def test_build_decimal_series(self, dc):
+        s = Series(dc, name="a")
+        s.index.name = "id"
+        result = s.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+
+        assert "pandas_version" in result["schema"]
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"name": "id", "type": "integer"},
+            {"name": "a", "type": "number", "extDtype": "decimal"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                ("data", [OrderedDict([("id", 0), ("a", "10")])]),
+            ]
+        )
+
+        assert result == expected
+
+    def test_build_string_series(self, sa):
+        s = Series(sa, name="a")
+        s.index.name = "id"
+        result = s.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+
+        assert "pandas_version" in result["schema"]
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"name": "id", "type": "integer"},
+            {"name": "a", "type": "string", "extDtype": "string"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                ("data", [OrderedDict([("id", 0), ("a", "pandas")])]),
+            ]
+        )
+
+        assert result == expected
+
+    def test_build_int64_series(self, ia):
+        s = Series(ia, name="a")
+        s.index.name = "id"
+        result = s.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+
+        assert "pandas_version" in result["schema"]
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"name": "id", "type": "integer"},
+            {"name": "a", "type": "integer", "extDtype": "Int64"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                ("data", [OrderedDict([("id", 0), ("a", 10)])]),
+            ]
+        )
+
+        assert result == expected
+
+    def test_to_json(self, da, dc, sa, ia):
+        df = DataFrame(
+            {
+                "A": da,
+                "B": dc,
+                "C": sa,
+                "D": ia,
+            }
+        )
+        df.index.name = "idx"
+        result = df.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+
+        assert "pandas_version" in result["schema"]
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            OrderedDict({"name": "idx", "type": "integer"}),
+            OrderedDict({"name": "A", "type": "any", "extDtype": "DateDtype"}),
+            OrderedDict({"name": "B", "type": "number", "extDtype": "decimal"}),
+            OrderedDict({"name": "C", "type": "string", "extDtype": "string"}),
+            OrderedDict({"name": "D", "type": "integer", "extDtype": "Int64"}),
+        ]
+
+        schema = OrderedDict({"fields": fields, "primaryKey": ["idx"]})
+        data = [
+            OrderedDict(
+                [
+                    ("idx", 0),
+                    ("A", "2021-10-10T00:00:00.000"),
+                    ("B", "10"),
+                    ("C", "pandas"),
+                    ("D", 10),
+                ]
+            )
+        ]
+        expected = OrderedDict([("schema", schema), ("data", data)])
+
+        assert result == expected
+
+    def test_json_ext_dtype_reading_roundtrip(self):
+        # GH#40255
+        df = DataFrame(
+            {
+                "a": Series([2, NA], dtype="Int64"),
+                "b": Series([1.5, NA], dtype="Float64"),
+                "c": Series([True, NA], dtype="boolean"),
+            },
+            index=Index([1, NA], dtype="Int64"),
+        )
+        expected = df.copy()
+        data_json = df.to_json(orient="table", indent=4)
+        result = read_json(StringIO(data_json), orient="table")
+        tm.assert_frame_equal(result, expected)
+
+    def test_json_ext_dtype_reading(self):
+        # GH#40255
+        data_json = """{
+            "schema":{
+                "fields":[
+                    {
+                        "name":"a",
+                        "type":"integer",
+                        "extDtype":"Int64"
+                    }
+                ],
+            },
+            "data":[
+                {
+                    "a":2
+                },
+                {
+                    "a":null
+                }
+            ]
+        }"""
+        result = read_json(StringIO(data_json), orient="table")
+        expected = DataFrame({"a": Series([2, NA], dtype="Int64")})
+        tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/json/test_normalize.py

@@ -0,0 +1,942 @@
+import json
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    json_normalize,
+)
+import pandas._testing as tm
+
+from pandas.io.json._normalize import nested_to_record
+
+
+@pytest.fixture
+def deep_nested():
+    # deeply nested data
+    return [
+        {
+            "country": "USA",
+            "states": [
+                {
+                    "name": "California",
+                    "cities": [
+                        {"name": "San Francisco", "pop": 12345},
+                        {"name": "Los Angeles", "pop": 12346},
+                    ],
+                },
+                {
+                    "name": "Ohio",
+                    "cities": [
+                        {"name": "Columbus", "pop": 1234},
+                        {"name": "Cleveland", "pop": 1236},
+                    ],
+                },
+            ],
+        },
+        {
+            "country": "Germany",
+            "states": [
+                {"name": "Bayern", "cities": [{"name": "Munich", "pop": 12347}]},
+                {
+                    "name": "Nordrhein-Westfalen",
+                    "cities": [
+                        {"name": "Duesseldorf", "pop": 1238},
+                        {"name": "Koeln", "pop": 1239},
+                    ],
+                },
+            ],
+        },
+    ]
+
+
+@pytest.fixture
+def state_data():
+    return [
+        {
+            "counties": [
+                {"name": "Dade", "population": 12345},
+                {"name": "Broward", "population": 40000},
+                {"name": "Palm Beach", "population": 60000},
+            ],
+            "info": {"governor": "Rick Scott"},
+            "shortname": "FL",
+            "state": "Florida",
+        },
+        {
+            "counties": [
+                {"name": "Summit", "population": 1234},
+                {"name": "Cuyahoga", "population": 1337},
+            ],
+            "info": {"governor": "John Kasich"},
+            "shortname": "OH",
+            "state": "Ohio",
+        },
+    ]
+
+
+@pytest.fixture
+def missing_metadata():
+    return [
+        {
+            "name": "Alice",
+            "addresses": [
+                {
+                    "number": 9562,
+                    "street": "Morris St.",
+                    "city": "Massillon",
+                    "state": "OH",
+                    "zip": 44646,
+                }
+            ],
+            "previous_residences": {"cities": [{"city_name": "Foo York City"}]},
+        },
+        {
+            "addresses": [
+                {
+                    "number": 8449,
+                    "street": "Spring St.",
+                    "city": "Elizabethton",
+                    "state": "TN",
+                    "zip": 37643,
+                }
+            ],
+            "previous_residences": {"cities": [{"city_name": "Barmingham"}]},
+        },
+    ]
+
+
+class TestJSONNormalize:
+    def test_simple_records(self):
+        recs = [
+            {"a": 1, "b": 2, "c": 3},
+            {"a": 4, "b": 5, "c": 6},
+            {"a": 7, "b": 8, "c": 9},
+            {"a": 10, "b": 11, "c": 12},
+        ]
+
+        result = json_normalize(recs)
+        expected = DataFrame(recs)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_simple_normalize(self, state_data):
+        result = json_normalize(state_data[0], "counties")
+        expected = DataFrame(state_data[0]["counties"])
+        tm.assert_frame_equal(result, expected)
+
+        result = json_normalize(state_data, "counties")
+
+        expected = []
+        for rec in state_data:
+            expected.extend(rec["counties"])
+        expected = DataFrame(expected)
+
+        tm.assert_frame_equal(result, expected)
+
+        result = json_normalize(state_data, "counties", meta="state")
+        expected["state"] = np.array(["Florida", "Ohio"]).repeat([3, 2])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_fields_list_type_normalize(self):
+        parse_metadata_fields_list_type = [
+            {"values": [1, 2, 3], "metadata": {"listdata": [1, 2]}}
+        ]
+        result = json_normalize(
+            parse_metadata_fields_list_type,
+            record_path=["values"],
+            meta=[["metadata", "listdata"]],
+        )
+        expected = DataFrame(
+            {0: [1, 2, 3], "metadata.listdata": [[1, 2], [1, 2], [1, 2]]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_empty_array(self):
+        result = json_normalize([])
+        expected = DataFrame()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data, record_path, exception_type",
+        [
+            ([{"a": 0}, {"a": 1}], None, None),
+            ({"a": [{"a": 0}, {"a": 1}]}, "a", None),
+            ('{"a": [{"a": 0}, {"a": 1}]}', None, NotImplementedError),
+            (None, None, NotImplementedError),
+        ],
+    )
+    def test_accepted_input(self, data, record_path, exception_type):
+        if exception_type is not None:
+            with pytest.raises(exception_type, match="^$"):
+                json_normalize(data, record_path=record_path)
+        else:
+            result = json_normalize(data, record_path=record_path)
+            expected = DataFrame([0, 1], columns=["a"])
+            tm.assert_frame_equal(result, expected)
+
+    def test_simple_normalize_with_separator(self, deep_nested):
+        # GH 14883
+        result = json_normalize({"A": {"A": 1, "B": 2}})
+        expected = DataFrame([[1, 2]], columns=["A.A", "A.B"])
+        tm.assert_frame_equal(result.reindex_like(expected), expected)
+
+        result = json_normalize({"A": {"A": 1, "B": 2}}, sep="_")
+        expected = DataFrame([[1, 2]], columns=["A_A", "A_B"])
+        tm.assert_frame_equal(result.reindex_like(expected), expected)
+
+        result = json_normalize({"A": {"A": 1, "B": 2}}, sep="\u03c3")
+        expected = DataFrame([[1, 2]], columns=["A\u03c3A", "A\u03c3B"])
+        tm.assert_frame_equal(result.reindex_like(expected), expected)
+
+        result = json_normalize(
+            deep_nested,
+            ["states", "cities"],
+            meta=["country", ["states", "name"]],
+            sep="_",
+        )
+        expected = Index(["name", "pop", "country", "states_name"]).sort_values()
+        assert result.columns.sort_values().equals(expected)
+
+    def test_normalize_with_multichar_separator(self):
+        # GH #43831
+        data = {"a": [1, 2], "b": {"b_1": 2, "b_2": (3, 4)}}
+        result = json_normalize(data, sep="__")
+        expected = DataFrame([[[1, 2], 2, (3, 4)]], columns=["a", "b__b_1", "b__b_2"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_value_array_record_prefix(self):
+        # GH 21536
+        result = json_normalize({"A": [1, 2]}, "A", record_prefix="Prefix.")
+        expected = DataFrame([[1], [2]], columns=["Prefix.0"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_nested_object_record_path(self):
+        # GH 22706
+        data = {
+            "state": "Florida",
+            "info": {
+                "governor": "Rick Scott",
+                "counties": [
+                    {"name": "Dade", "population": 12345},
+                    {"name": "Broward", "population": 40000},
+                    {"name": "Palm Beach", "population": 60000},
+                ],
+            },
+        }
+        result = json_normalize(data, record_path=["info", "counties"])
+        expected = DataFrame(
+            [["Dade", 12345], ["Broward", 40000], ["Palm Beach", 60000]],
+            columns=["name", "population"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_more_deeply_nested(self, deep_nested):
+        result = json_normalize(
+            deep_nested, ["states", "cities"], meta=["country", ["states", "name"]]
+        )
+        ex_data = {
+            "country": ["USA"] * 4 + ["Germany"] * 3,
+            "states.name": [
+                "California",
+                "California",
+                "Ohio",
+                "Ohio",
+                "Bayern",
+                "Nordrhein-Westfalen",
+                "Nordrhein-Westfalen",
+            ],
+            "name": [
+                "San Francisco",
+                "Los Angeles",
+                "Columbus",
+                "Cleveland",
+                "Munich",
+                "Duesseldorf",
+                "Koeln",
+            ],
+            "pop": [12345, 12346, 1234, 1236, 12347, 1238, 1239],
+        }
+
+        expected = DataFrame(ex_data, columns=result.columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_shallow_nested(self):
+        data = [
+            {
+                "state": "Florida",
+                "shortname": "FL",
+                "info": {"governor": "Rick Scott"},
+                "counties": [
+                    {"name": "Dade", "population": 12345},
+                    {"name": "Broward", "population": 40000},
+                    {"name": "Palm Beach", "population": 60000},
+                ],
+            },
+            {
+                "state": "Ohio",
+                "shortname": "OH",
+                "info": {"governor": "John Kasich"},
+                "counties": [
+                    {"name": "Summit", "population": 1234},
+                    {"name": "Cuyahoga", "population": 1337},
+                ],
+            },
+        ]
+
+        result = json_normalize(
+            data, "counties", ["state", "shortname", ["info", "governor"]]
+        )
+        ex_data = {
+            "name": ["Dade", "Broward", "Palm Beach", "Summit", "Cuyahoga"],
+            "state": ["Florida"] * 3 + ["Ohio"] * 2,
+            "shortname": ["FL", "FL", "FL", "OH", "OH"],
+            "info.governor": ["Rick Scott"] * 3 + ["John Kasich"] * 2,
+            "population": [12345, 40000, 60000, 1234, 1337],
+        }
+        expected = DataFrame(ex_data, columns=result.columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_nested_meta_path_with_nested_record_path(self, state_data):
+        # GH 27220
+        result = json_normalize(
+            data=state_data,
+            record_path=["counties"],
+            meta=["state", "shortname", ["info", "governor"]],
+            errors="ignore",
+        )
+
+        ex_data = {
+            "name": ["Dade", "Broward", "Palm Beach", "Summit", "Cuyahoga"],
+            "population": [12345, 40000, 60000, 1234, 1337],
+            "state": ["Florida"] * 3 + ["Ohio"] * 2,
+            "shortname": ["FL"] * 3 + ["OH"] * 2,
+            "info.governor": ["Rick Scott"] * 3 + ["John Kasich"] * 2,
+        }
+
+        expected = DataFrame(ex_data)
+        tm.assert_frame_equal(result, expected)
+
+    def test_meta_name_conflict(self):
+        data = [
+            {
+                "foo": "hello",
+                "bar": "there",
+                "data": [
+                    {"foo": "something", "bar": "else"},
+                    {"foo": "something2", "bar": "else2"},
+                ],
+            }
+        ]
+
+        msg = r"Conflicting metadata name (foo|bar), need distinguishing prefix"
+        with pytest.raises(ValueError, match=msg):
+            json_normalize(data, "data", meta=["foo", "bar"])
+
+        result = json_normalize(data, "data", meta=["foo", "bar"], meta_prefix="meta")
+
+        for val in ["metafoo", "metabar", "foo", "bar"]:
+            assert val in result
+
+    def test_meta_parameter_not_modified(self):
+        # GH 18610
+        data = [
+            {
+                "foo": "hello",
+                "bar": "there",
+                "data": [
+                    {"foo": "something", "bar": "else"},
+                    {"foo": "something2", "bar": "else2"},
+                ],
+            }
+        ]
+
+        COLUMNS = ["foo", "bar"]
+        result = json_normalize(data, "data", meta=COLUMNS, meta_prefix="meta")
+
+        assert COLUMNS == ["foo", "bar"]
+        for val in ["metafoo", "metabar", "foo", "bar"]:
+            assert val in result
+
+    def test_record_prefix(self, state_data):
+        result = json_normalize(state_data[0], "counties")
+        expected = DataFrame(state_data[0]["counties"])
+        tm.assert_frame_equal(result, expected)
+
+        result = json_normalize(
+            state_data, "counties", meta="state", record_prefix="county_"
+        )
+
+        expected = []
+        for rec in state_data:
+            expected.extend(rec["counties"])
+        expected = DataFrame(expected)
+        expected = expected.rename(columns=lambda x: "county_" + x)
+        expected["state"] = np.array(["Florida", "Ohio"]).repeat([3, 2])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_record_prefix_no_record_path_series(self):
+        # Ensure record_prefix is applied when record_path is None for Series input
+        s = Series([{"k": f"{i}", "m": "q"} for i in range(3)])
+        result = json_normalize(s, record_prefix="T.")
+        expected = DataFrame(
+            [
+                {"T.k": "0", "T.m": "q"},
+                {"T.k": "1", "T.m": "q"},
+                {"T.k": "2", "T.m": "q"},
+            ]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_non_ascii_key(self):
+        testjson = (
+            b'[{"\xc3\x9cnic\xc3\xb8de":0,"sub":{"A":1, "B":2}},'
+            b'{"\xc3\x9cnic\xc3\xb8de":1,"sub":{"A":3, "B":4}}]'
+        ).decode("utf8")
+
+        testdata = {
+            b"\xc3\x9cnic\xc3\xb8de".decode("utf8"): [0, 1],
+            "sub.A": [1, 3],
+            "sub.B": [2, 4],
+        }
+        expected = DataFrame(testdata)
+
+        result = json_normalize(json.loads(testjson))
+        tm.assert_frame_equal(result, expected)
+
+    def test_missing_field(self):
+        # GH20030:
+        author_missing_data = [
+            {"info": None},
+            {
+                "info": {"created_at": "11/08/1993", "last_updated": "26/05/2012"},
+                "author_name": {"first": "Jane", "last_name": "Doe"},
+            },
+        ]
+        result = json_normalize(author_missing_data)
+        ex_data = [
+            {
+                "info": np.nan,
+                "info.created_at": np.nan,
+                "info.last_updated": np.nan,
+                "author_name.first": np.nan,
+                "author_name.last_name": np.nan,
+            },
+            {
+                "info": None,
+                "info.created_at": "11/08/1993",
+                "info.last_updated": "26/05/2012",
+                "author_name.first": "Jane",
+                "author_name.last_name": "Doe",
+            },
+        ]
+        expected = DataFrame(ex_data)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "max_level,expected",
+        [
+            (
+                0,
+                [
+                    {
+                        "TextField": "Some text",
+                        "UserField": {"Id": "ID001", "Name": "Name001"},
+                        "CreatedBy": {"Name": "User001"},
+                        "Image": {"a": "b"},
+                    },
+                    {
+                        "TextField": "Some text",
+                        "UserField": {"Id": "ID001", "Name": "Name001"},
+                        "CreatedBy": {"Name": "User001"},
+                        "Image": {"a": "b"},
+                    },
+                ],
+            ),
+            (
+                1,
+                [
+                    {
+                        "TextField": "Some text",
+                        "UserField.Id": "ID001",
+                        "UserField.Name": "Name001",
+                        "CreatedBy": {"Name": "User001"},
+                        "Image": {"a": "b"},
+                    },
+                    {
+                        "TextField": "Some text",
+                        "UserField.Id": "ID001",
+                        "UserField.Name": "Name001",
+                        "CreatedBy": {"Name": "User001"},
+                        "Image": {"a": "b"},
+                    },
+                ],
+            ),
+        ],
+    )
+    def test_max_level_with_records_path(self, max_level, expected):
+        # GH23843: Enhanced JSON normalize
+        test_input = [
+            {
+                "CreatedBy": {"Name": "User001"},
+                "Lookup": [
+                    {
+                        "TextField": "Some text",
+                        "UserField": {"Id": "ID001", "Name": "Name001"},
+                    },
+                    {
+                        "TextField": "Some text",
+                        "UserField": {"Id": "ID001", "Name": "Name001"},
+                    },
+                ],
+                "Image": {"a": "b"},
+                "tags": [
+                    {"foo": "something", "bar": "else"},
+                    {"foo": "something2", "bar": "else2"},
+                ],
+            }
+        ]
+
+        result = json_normalize(
+            test_input,
+            record_path=["Lookup"],
+            meta=[["CreatedBy"], ["Image"]],
+            max_level=max_level,
+        )
+        expected_df = DataFrame(data=expected, columns=result.columns.values)
+        tm.assert_equal(expected_df, result)
+
+    @pytest.mark.parametrize("max_level", [0, None])
+    def test_json_normalize_non_dict_items(self, max_level):
+        # gh-62829, gh-64188
+        data_list = [np.nan, {"id": 12}, {"id": 13}]
+
+        result = json_normalize(data_list, max_level=max_level)
+        expected = DataFrame({"id": [np.nan, 12, 13]})
+        tm.assert_frame_equal(result, expected)
+
+        msg = "All items in data must be of type dict or NA-like, found float"
+        with pytest.raises(TypeError, match=msg):
+            json_normalize([1.0, {"id": 12}], max_level=max_level)
+
+    def test_nested_flattening_consistent(self):
+        # see gh-21537
+        df1 = json_normalize([{"A": {"B": 1}}])
+        df2 = json_normalize({"dummy": [{"A": {"B": 1}}]}, "dummy")
+
+        # They should be the same.
+        tm.assert_frame_equal(df1, df2)
+
+    def test_nonetype_record_path(self, nulls_fixture):
+        # see gh-30148
+        # should not raise TypeError
+        result = json_normalize(
+            [
+                {"state": "Texas", "info": nulls_fixture},
+                {"state": "Florida", "info": [{"i": 2}]},
+            ],
+            record_path=["info"],
+        )
+        expected = DataFrame({"i": 2}, index=range(1))
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize("value", ["false", "true", "{}", "1", '"text"'])
+    def test_non_list_record_path_errors(self, value):
+        # see gh-30148, GH 26284
+        parsed_value = json.loads(value)
+        test_input = {"state": "Texas", "info": parsed_value}
+        test_path = "info"
+        msg = (
+            f"Path must contain list or null, "
+            f"but got {type(parsed_value).__name__} at 'info'"
+        )
+        with pytest.raises(TypeError, match=msg):
+            json_normalize([test_input], record_path=[test_path])
+
+    def test_meta_non_iterable(self):
+        # GH 31507
+        data = """[{"id": 99, "data": [{"one": 1, "two": 2}]}]"""
+
+        result = json_normalize(json.loads(data), record_path=["data"], meta=["id"])
+        expected = DataFrame(
+            {"one": [1], "two": [2], "id": np.array([99], dtype=object)}
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_generator(self, state_data):
+        # GH35923 Fix pd.json_normalize to not skip the first element of a
+        # generator input
+        def generator_data():
+            yield from state_data[0]["counties"]
+
+        result = json_normalize(generator_data())
+        expected = DataFrame(state_data[0]["counties"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_top_column_with_leading_underscore(self):
+        # 49861
+        data = {"_id": {"a1": 10, "l2": {"l3": 0}}, "gg": 4}
+        result = json_normalize(data, sep="_")
+        expected = DataFrame([[4, 10, 0]], columns=["gg", "_id_a1", "_id_l2_l3"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_series_index(self, state_data):
+        idx = Index([7, 8])
+        series = Series(state_data, index=idx)
+        result = json_normalize(series)
+        tm.assert_index_equal(result.index, idx)
+        result = json_normalize(series, "counties")
+        tm.assert_index_equal(result.index, idx.repeat([3, 2]))
+
+
+class TestNestedToRecord:
+    def test_flat_stays_flat(self):
+        recs = [{"flat1": 1, "flat2": 2}, {"flat3": 3, "flat2": 4}]
+        result = nested_to_record(recs)
+        expected = recs
+        assert result == expected
+
+    def test_one_level_deep_flattens(self):
+        data = {"flat1": 1, "dict1": {"c": 1, "d": 2}}
+
+        result = nested_to_record(data)
+        expected = {"dict1.c": 1, "dict1.d": 2, "flat1": 1}
+
+        assert result == expected
+
+    def test_nested_flattens(self):
+        data = {
+            "flat1": 1,
+            "dict1": {"c": 1, "d": 2},
+            "nested": {"e": {"c": 1, "d": 2}, "d": 2},
+        }
+
+        result = nested_to_record(data)
+        expected = {
+            "dict1.c": 1,
+            "dict1.d": 2,
+            "flat1": 1,
+            "nested.d": 2,
+            "nested.e.c": 1,
+            "nested.e.d": 2,
+        }
+
+        assert result == expected
+
+    def test_json_normalize_errors(self, missing_metadata):
+        # GH14583:
+        # If meta keys are not always present a new option to set
+        # errors='ignore' has been implemented
+
+        msg = (
+            "Key 'name' not found. To replace missing values of "
+            "'name' with np.nan, pass in errors='ignore'"
+        )
+        with pytest.raises(KeyError, match=msg):
+            json_normalize(
+                data=missing_metadata,
+                record_path="addresses",
+                meta="name",
+                errors="raise",
+            )
+
+    def test_missing_meta(self, missing_metadata):
+        # GH25468
+        # If metadata is nullable with errors set to ignore, the null values
+        # should be numpy.nan values
+        result = json_normalize(
+            data=missing_metadata, record_path="addresses", meta="name", errors="ignore"
+        )
+        ex_data = [
+            [9562, "Morris St.", "Massillon", "OH", 44646, "Alice"],
+            [8449, "Spring St.", "Elizabethton", "TN", 37643, np.nan],
+        ]
+        columns = ["number", "street", "city", "state", "zip", "name"]
+        expected = DataFrame(ex_data, columns=columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_missing_nested_meta(self):
+        # GH44312
+        # If errors="ignore" and nested metadata is null, we should return nan
+        data = {"meta": "foo", "nested_meta": None, "value": [{"rec": 1}, {"rec": 2}]}
+        result = json_normalize(
+            data,
+            record_path="value",
+            meta=["meta", ["nested_meta", "leaf"]],
+            errors="ignore",
+        )
+        ex_data = [[1, "foo", np.nan], [2, "foo", np.nan]]
+        columns = ["rec", "meta", "nested_meta.leaf"]
+        expected = DataFrame(ex_data, columns=columns).astype(
+            {"nested_meta.leaf": object}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # If errors="raise" and nested metadata is null, we should raise with the
+        # key of the first missing level
+        with pytest.raises(KeyError, match="'leaf' not found"):
+            json_normalize(
+                data,
+                record_path="value",
+                meta=["meta", ["nested_meta", "leaf"]],
+                errors="raise",
+            )
+
+    def test_missing_meta_multilevel_record_path_errors_raise(self, missing_metadata):
+        # GH41876
+        # Ensure errors='raise' works as intended even when a record_path of length
+        # greater than one is passed in
+        msg = (
+            "Key 'name' not found. To replace missing values of "
+            "'name' with np.nan, pass in errors='ignore'"
+        )
+        with pytest.raises(KeyError, match=msg):
+            json_normalize(
+                data=missing_metadata,
+                record_path=["previous_residences", "cities"],
+                meta="name",
+                errors="raise",
+            )
+
+    def test_missing_meta_multilevel_record_path_errors_ignore(self, missing_metadata):
+        # GH41876
+        # Ensure errors='ignore' works as intended even when a record_path of length
+        # greater than one is passed in
+        result = json_normalize(
+            data=missing_metadata,
+            record_path=["previous_residences", "cities"],
+            meta="name",
+            errors="ignore",
+        )
+        ex_data = [
+            ["Foo York City", "Alice"],
+            ["Barmingham", np.nan],
+        ]
+        columns = ["city_name", "name"]
+        expected = DataFrame(ex_data, columns=columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_donot_drop_nonevalues(self):
+        # GH21356
+        data = [
+            {"info": None, "author_name": {"first": "Smith", "last_name": "Appleseed"}},
+            {
+                "info": {"created_at": "11/08/1993", "last_updated": "26/05/2012"},
+                "author_name": {"first": "Jane", "last_name": "Doe"},
+            },
+        ]
+        result = nested_to_record(data)
+        expected = [
+            {
+                "info": None,
+                "author_name.first": "Smith",
+                "author_name.last_name": "Appleseed",
+            },
+            {
+                "author_name.first": "Jane",
+                "author_name.last_name": "Doe",
+                "info.created_at": "11/08/1993",
+                "info.last_updated": "26/05/2012",
+            },
+        ]
+
+        assert result == expected
+
+    def test_nonetype_top_level_bottom_level(self):
+        # GH21158: If inner level json has a key with a null value
+        # make sure it does not do a new_d.pop twice and except
+        data = {
+            "id": None,
+            "location": {
+                "country": {
+                    "state": {
+                        "id": None,
+                        "town.info": {
+                            "id": None,
+                            "region": None,
+                            "x": 49.151580810546875,
+                            "y": -33.148521423339844,
+                            "z": 27.572303771972656,
+                        },
+                    }
+                }
+            },
+        }
+        result = nested_to_record(data)
+        expected = {
+            "id": None,
+            "location.country.state.id": None,
+            "location.country.state.town.info.id": None,
+            "location.country.state.town.info.region": None,
+            "location.country.state.town.info.x": 49.151580810546875,
+            "location.country.state.town.info.y": -33.148521423339844,
+            "location.country.state.town.info.z": 27.572303771972656,
+        }
+        assert result == expected
+
+    def test_nonetype_multiple_levels(self):
+        # GH21158: If inner level json has a key with a null value
+        # make sure it does not do a new_d.pop twice and except
+        data = {
+            "id": None,
+            "location": {
+                "id": None,
+                "country": {
+                    "id": None,
+                    "state": {
+                        "id": None,
+                        "town.info": {
+                            "region": None,
+                            "x": 49.151580810546875,
+                            "y": -33.148521423339844,
+                            "z": 27.572303771972656,
+                        },
+                    },
+                },
+            },
+        }
+        result = nested_to_record(data)
+        expected = {
+            "id": None,
+            "location.id": None,
+            "location.country.id": None,
+            "location.country.state.id": None,
+            "location.country.state.town.info.region": None,
+            "location.country.state.town.info.x": 49.151580810546875,
+            "location.country.state.town.info.y": -33.148521423339844,
+            "location.country.state.town.info.z": 27.572303771972656,
+        }
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "max_level, expected",
+        [
+            (
+                None,
+                [
+                    {
+                        "CreatedBy.Name": "User001",
+                        "Lookup.TextField": "Some text",
+                        "Lookup.UserField.Id": "ID001",
+                        "Lookup.UserField.Name": "Name001",
+                        "Image.a": "b",
+                    }
+                ],
+            ),
+            (
+                0,
+                [
+                    {
+                        "CreatedBy": {"Name": "User001"},
+                        "Lookup": {
+                            "TextField": "Some text",
+                            "UserField": {"Id": "ID001", "Name": "Name001"},
+                        },
+                        "Image": {"a": "b"},
+                    }
+                ],
+            ),
+            (
+                1,
+                [
+                    {
+                        "CreatedBy.Name": "User001",
+                        "Lookup.TextField": "Some text",
+                        "Lookup.UserField": {"Id": "ID001", "Name": "Name001"},
+                        "Image.a": "b",
+                    }
+                ],
+            ),
+        ],
+    )
+    def test_with_max_level(self, max_level, expected):
+        # GH23843: Enhanced JSON normalize
+        max_level_test_input_data = [
+            {
+                "CreatedBy": {"Name": "User001"},
+                "Lookup": {
+                    "TextField": "Some text",
+                    "UserField": {"Id": "ID001", "Name": "Name001"},
+                },
+                "Image": {"a": "b"},
+            }
+        ]
+        output = nested_to_record(max_level_test_input_data, max_level=max_level)
+        assert output == expected
+
+    def test_with_large_max_level(self):
+        # GH23843: Enhanced JSON normalize
+        max_level = 100
+        input_data = [
+            {
+                "CreatedBy": {
+                    "user": {
+                        "name": {"firstname": "Leo", "LastName": "Thomson"},
+                        "family_tree": {
+                            "father": {
+                                "name": "Father001",
+                                "father": {
+                                    "Name": "Father002",
+                                    "father": {
+                                        "name": "Father003",
+                                        "father": {"Name": "Father004"},
+                                    },
+                                },
+                            }
+                        },
+                    }
+                }
+            }
+        ]
+        expected = [
+            {
+                "CreatedBy.user.name.firstname": "Leo",
+                "CreatedBy.user.name.LastName": "Thomson",
+                "CreatedBy.user.family_tree.father.name": "Father001",
+                "CreatedBy.user.family_tree.father.father.Name": "Father002",
+                "CreatedBy.user.family_tree.father.father.father.name": "Father003",
+                "CreatedBy.user.family_tree.father.father.father.father.Name": "Father004",  # noqa: E501
+            }
+        ]
+        output = nested_to_record(input_data, max_level=max_level)
+        assert output == expected
+
+    def test_series_non_zero_index(self):
+        # GH 19020
+        data = {
+            0: {"id": 1, "name": "Foo", "elements": {"a": 1}},
+            1: {"id": 2, "name": "Bar", "elements": {"b": 2}},
+            2: {"id": 3, "name": "Baz", "elements": {"c": 3}},
+        }
+        s = Series(data)
+        s.index = [1, 2, 3]
+        result = json_normalize(s)
+        expected = DataFrame(
+            {
+                "id": [1, 2, 3],
+                "name": ["Foo", "Bar", "Baz"],
+                "elements.a": [1.0, np.nan, np.nan],
+                "elements.b": [np.nan, 2.0, np.nan],
+                "elements.c": [np.nan, np.nan, 3.0],
+            },
+            index=[1, 2, 3],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_json_normalize_meta_string_validation(self):
+        # GH 63019
+        data = [{"a": 1, 12: "meta_value", "nested": [{"b": 2}]}]
+
+        # Test non-string meta raises TypeError consistently
+        with pytest.raises(TypeError, match="must be strings"):
+            json_normalize(data, meta=[12])
+
+        with pytest.raises(TypeError, match="must be strings"):
+            json_normalize(data, record_path=["nested"], meta=[12])

.venv/lib/python3.13/site-packages/pandas/tests/io/json/test_pandas.py

@@ -0,0 +1,2387 @@
+import datetime
+from datetime import timedelta
+from io import (
+    BytesIO,
+    StringIO,
+)
+import json
+import os
+import sys
+import uuid
+
+import numpy as np
+import pytest
+
+from pandas._config import using_string_dtype
+
+from pandas.compat import IS64
+from pandas.errors import Pandas4Warning
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    NA,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    RangeIndex,
+    Series,
+    Timestamp,
+    date_range,
+    read_json,
+)
+import pandas._testing as tm
+
+from pandas.io.json import ujson_dumps
+
+
+def test_literal_json_raises():
+    # PR 53409
+    jsonl = """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}"""
+
+    msg = r".* does not exist"
+
+    with pytest.raises(FileNotFoundError, match=msg):
+        read_json(jsonl, lines=False)
+
+    with pytest.raises(FileNotFoundError, match=msg):
+        read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=True)
+
+    with pytest.raises(FileNotFoundError, match=msg):
+        read_json(
+            '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}\n',
+            lines=False,
+        )
+
+    with pytest.raises(FileNotFoundError, match=msg):
+        read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=False)
+
+
+def assert_json_roundtrip_equal(result, expected, orient):
+    if orient in ("records", "values"):
+        expected = expected.reset_index(drop=True)
+    if orient == "values":
+        expected.columns = range(len(expected.columns))
+    tm.assert_frame_equal(result, expected)
+
+
+class TestPandasContainer:
+    @pytest.fixture
+    def datetime_series(self):
+        # Same as usual datetime_series, but with index freq set to None,
+        #  since that doesn't round-trip, see GH#33711
+        ser = Series(
+            1.1 * np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10, unit="ns"),
+            name="ts",
+        )
+        ser.index = ser.index._with_freq(None)
+        return ser
+
+    @pytest.fixture
+    def datetime_frame(self):
+        # Same as usual datetime_frame, but with index freq set to None,
+        #  since that doesn't round-trip, see GH#33711
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((30, 4)),
+            columns=Index(list("ABCD")),
+            index=date_range("2000-01-01", periods=30, freq="B", unit="ns"),
+        )
+        df.index = df.index._with_freq(None)
+        return df
+
+    def test_frame_double_encoded_labels(self, orient):
+        df = DataFrame(
+            [["a", "b"], ["c", "d"]],
+            index=['index " 1', "index / 2"],
+            columns=["a \\ b", "y / z"],
+        )
+
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient)
+        expected = df.copy()
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("orient", ["split", "records", "values"])
+    def test_frame_non_unique_index(self, orient):
+        df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 1], columns=["x", "y"])
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient)
+        expected = df.copy()
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("orient", ["index", "columns"])
+    def test_frame_non_unique_index_raises(self, orient):
+        df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 1], columns=["x", "y"])
+        msg = f"DataFrame index must be unique for orient='{orient}'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient=orient)
+
+    @pytest.mark.parametrize("orient", ["split", "values"])
+    @pytest.mark.parametrize(
+        "data",
+        [
+            [["a", "b"], ["c", "d"]],
+            [[1.5, 2.5], [3.5, 4.5]],
+            [[1, 2.5], [3, 4.5]],
+            [
+                [Timestamp("20130101").as_unit("s"), 3.5],
+                [Timestamp("20130102").as_unit("s"), 4.5],
+            ],
+        ],
+    )
+    def test_frame_non_unique_columns(self, orient, data, request):
+        df = DataFrame(data, index=[1, 2], columns=["x", "x"])
+
+        expected_warning = None
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        if df.iloc[:, 0].dtype == "datetime64[s]":
+            expected_warning = Pandas4Warning
+
+        with tm.assert_produces_warning(expected_warning, match=msg):
+            result = read_json(
+                StringIO(df.to_json(orient=orient)), orient=orient, convert_dates=["x"]
+            )
+        if orient == "values":
+            expected = DataFrame(data)
+            if expected.iloc[:, 0].dtype == "datetime64[s]":
+                # orient == "values" by default will write Timestamp objects out
+                # in milliseconds;
+                # TODO: a to_epoch method would also solve; see GH 14772
+                dta = expected.iloc[:, 0]._values
+                expected.isetitem(0, dta.as_unit("ms").astype(np.int64))
+        elif orient == "split":
+            expected = df
+            expected.columns = ["x", "x.1"]
+            if expected["x"].dtype.kind == "M":
+                expected["x"] = expected["x"].astype("M8[ms]")
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("orient", ["index", "columns", "records"])
+    def test_frame_non_unique_columns_raises(self, orient):
+        df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 2], columns=["x", "x"])
+
+        msg = f"DataFrame columns must be unique for orient='{orient}'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient=orient)
+
+    def test_frame_default_orient(self, float_frame):
+        assert float_frame.to_json() == float_frame.to_json(orient="columns")
+
+    @pytest.mark.parametrize("dtype", [False, float])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_simple(self, orient, convert_axes, dtype, float_frame):
+        data = StringIO(float_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes, dtype=dtype)
+
+        expected = float_frame
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("dtype", [False, np.int64])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_intframe(self, orient, convert_axes, dtype, int_frame):
+        data = StringIO(int_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes, dtype=dtype)
+        expected = int_frame
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("dtype", [None, np.float64, int, "U3"])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_str_axes(self, orient, convert_axes, dtype):
+        df = DataFrame(
+            np.zeros((200, 4)),
+            columns=[str(i) for i in range(4)],
+            index=[str(i) for i in range(200)],
+            dtype=dtype,
+        )
+
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes, dtype=dtype)
+
+        expected = df.copy()
+        if not dtype:
+            expected = expected.astype(np.int64)
+
+        # index columns, and records orients cannot fully preserve the string
+        # dtype for axes as the index and column labels are used as keys in
+        # JSON objects. JSON keys are by definition strings, so there's no way
+        # to disambiguate whether those keys actually were strings or numeric
+        # beforehand and numeric wins out.
+        if convert_axes and (orient in ("index", "columns")):
+            expected.columns = expected.columns.astype(np.int64)
+            expected.index = expected.index.astype(np.int64)
+        elif orient == "records" and convert_axes:
+            expected.columns = expected.columns.astype(np.int64)
+        elif convert_axes and orient == "split":
+            expected.columns = expected.columns.astype(np.int64)
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_categorical(
+        self, request, orient, convert_axes, using_infer_string
+    ):
+        # TODO: create a better frame to test with and improve coverage
+        if orient in ("index", "columns"):
+            request.applymarker(
+                pytest.mark.xfail(
+                    reason=f"Can't have duplicate index values for orient '{orient}')"
+                )
+            )
+
+        data = {
+            c: np.random.default_rng(i).standard_normal(30)
+            for i, c in enumerate(list("ABCD"))
+        }
+        cat = ["bah"] * 5 + ["bar"] * 5 + ["baz"] * 5 + ["foo"] * 15
+        data["E"] = list(reversed(cat))
+        data["sort"] = np.arange(30, dtype="int64")
+        categorical_frame = DataFrame(data, index=pd.CategoricalIndex(cat, name="E"))
+        data = StringIO(categorical_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes)
+
+        expected = categorical_frame.copy()
+        expected.index = expected.index.astype(
+            str if not using_infer_string else "str"
+        )  # Categorical not preserved
+        expected.index.name = None  # index names aren't preserved in JSON
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_empty(self, orient, convert_axes):
+        empty_frame = DataFrame()
+        data = StringIO(empty_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes)
+        if orient == "split":
+            idx = Index([], dtype=(float if convert_axes else object))
+            expected = DataFrame(index=idx, columns=idx)
+        elif orient in ["index", "columns"]:
+            expected = DataFrame()
+        else:
+            expected = empty_frame.copy()
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype_backend", [None, pytest.param("pyarrow", marks=td.skip_if_no("pyarrow"))]
+    )
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_timestamp(
+        self, orient, convert_axes, dtype_backend, datetime_frame
+    ):
+        # TODO: improve coverage with date_format parameter
+        expected = datetime_frame.copy()
+        if dtype_backend is not None:
+            datetime_frame.index = Series(datetime_frame.index).convert_dtypes(
+                dtype_backend=dtype_backend
+            )
+        data = StringIO(datetime_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes)
+
+        if not convert_axes:  # one off for ts handling
+            # DTI gets converted to epoch values
+            idx = expected.index.view(np.int64) // 1000000
+            if orient != "split":  # TODO: handle consistently across orients
+                idx = idx.astype(str)
+
+            expected.index = idx
+        else:
+            expected.index = expected.index.as_unit("ms")
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_mixed(self, orient, convert_axes):
+        index = Index(["a", "b", "c", "d", "e"])
+        values = {
+            "A": [0.0, 1.0, 2.0, 3.0, 4.0],
+            "B": [0.0, 1.0, 0.0, 1.0, 0.0],
+            "C": ["foo1", "foo2", "foo3", "foo4", "foo5"],
+            "D": [True, False, True, False, True],
+        }
+
+        df = DataFrame(data=values, index=index)
+
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes)
+
+        expected = df.copy()
+        expected = expected.assign(**expected.select_dtypes("number").astype(np.int64))
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.xfail(
+        reason="#50456 Column multiindex is stored and loaded differently",
+        raises=AssertionError,
+    )
+    @pytest.mark.parametrize(
+        "columns",
+        [
+            [["2022", "2022"], ["JAN", "FEB"]],
+            [["2022", "2023"], ["JAN", "JAN"]],
+            [["2022", "2022"], ["JAN", "JAN"]],
+        ],
+    )
+    def test_roundtrip_multiindex(self, columns):
+        df = DataFrame(
+            [[1, 2], [3, 4]],
+            columns=pd.MultiIndex.from_arrays(columns),
+        )
+        data = StringIO(df.to_json(orient="split"))
+        result = read_json(data, orient="split")
+        tm.assert_frame_equal(result, df)
+
+    @pytest.mark.parametrize(
+        "data,msg,orient",
+        [
+            ('{"key":b:a:d}', "Expected object or value", "columns"),
+            # too few indices
+            (
+                '{"columns":["A","B"],'
+                '"index":["2","3"],'
+                '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}',
+                "|".join(
+                    [
+                        r"Length of values \(3\) does not match length of index \(2\)",
+                    ]
+                ),
+                "split",
+            ),
+            # too many columns
+            (
+                '{"columns":["A","B","C"],'
+                '"index":["1","2","3"],'
+                '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}',
+                "3 columns passed, passed data had 2 columns",
+                "split",
+            ),
+            # bad key
+            (
+                '{"badkey":["A","B"],'
+                '"index":["2","3"],'
+                '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}',
+                r"unexpected key\(s\): badkey",
+                "split",
+            ),
+        ],
+    )
+    def test_frame_from_json_bad_data_raises(self, data, msg, orient):
+        with pytest.raises(ValueError, match=msg):
+            read_json(StringIO(data), orient=orient)
+
+    @pytest.mark.parametrize("dtype", [True, False])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_frame_from_json_missing_data(self, orient, convert_axes, dtype):
+        num_df = DataFrame([[1, 2], [4, 5, 6]])
+
+        result = read_json(
+            StringIO(num_df.to_json(orient=orient)),
+            orient=orient,
+            convert_axes=convert_axes,
+            dtype=dtype,
+        )
+        assert np.isnan(result.iloc[0, 2])
+
+        obj_df = DataFrame([["1", "2"], ["4", "5", "6"]])
+        result = read_json(
+            StringIO(obj_df.to_json(orient=orient)),
+            orient=orient,
+            convert_axes=convert_axes,
+            dtype=dtype,
+        )
+        assert np.isnan(result.iloc[0, 2])
+
+    @pytest.mark.parametrize("dtype", [True, False])
+    def test_frame_read_json_dtype_missing_value(self, dtype):
+        # GH28501 Parse missing values using read_json with dtype=False
+        # to NaN instead of None
+        result = read_json(StringIO("[null]"), dtype=dtype)
+        expected = DataFrame([np.nan], dtype=object if not dtype else None)
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("inf", [np.inf, -np.inf])
+    @pytest.mark.parametrize("dtype", [True, False])
+    def test_frame_infinity(self, inf, dtype):
+        # infinities get mapped to nulls which get mapped to NaNs during
+        # deserialisation
+        df = DataFrame([[1, 2], [4, 5, 6]])
+        df.loc[0, 2] = inf
+
+        data = StringIO(df.to_json())
+        result = read_json(data, dtype=dtype)
+        assert np.isnan(result.iloc[0, 2])
+
+    @pytest.mark.skipif(not IS64, reason="not compliant on 32-bit, xref #15865")
+    @pytest.mark.parametrize(
+        "value,precision,expected_val",
+        [
+            (0.95, 1, 1.0),
+            (1.95, 1, 2.0),
+            (-1.95, 1, -2.0),
+            (0.995, 2, 1.0),
+            (0.9995, 3, 1.0),
+            (0.99999999999999944, 15, 1.0),
+        ],
+    )
+    def test_frame_to_json_float_precision(self, value, precision, expected_val):
+        df = DataFrame([{"a_float": value}])
+        encoded = df.to_json(double_precision=precision)
+        assert encoded == f'{{"a_float":{{"0":{expected_val}}}}}'
+
+    def test_frame_to_json_except(self):
+        df = DataFrame([1, 2, 3])
+        msg = "Invalid value 'garbage' for option 'orient'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient="garbage")
+
+    def test_frame_empty(self):
+        df = DataFrame(columns=["jim", "joe"])
+        assert not df._is_mixed_type
+
+        data = StringIO(df.to_json())
+        result = read_json(data, dtype=dict(df.dtypes))
+        tm.assert_frame_equal(result, df, check_index_type=False)
+
+    def test_frame_empty_to_json(self):
+        # GH 7445
+        df = DataFrame({"test": []}, index=[])
+        result = df.to_json(orient="columns")
+        expected = '{"test":{}}'
+        assert result == expected
+
+    def test_frame_empty_mixedtype(self):
+        # mixed type
+        df = DataFrame(columns=["jim", "joe"])
+        df["joe"] = df["joe"].astype("i8")
+        assert df._is_mixed_type
+        data = df.to_json()
+        tm.assert_frame_equal(
+            read_json(StringIO(data), dtype=dict(df.dtypes)),
+            df,
+            check_index_type=False,
+        )
+
+    def test_frame_mixedtype_orient(self):  # GH10289
+        vals = [
+            [10, 1, "foo", 0.1, 0.01],
+            [20, 2, "bar", 0.2, 0.02],
+            [30, 3, "baz", 0.3, 0.03],
+            [40, 4, "qux", 0.4, 0.04],
+        ]
+
+        df = DataFrame(
+            vals, index=list("abcd"), columns=["1st", "2nd", "3rd", "4th", "5th"]
+        )
+
+        assert df._is_mixed_type
+        right = df.copy()
+
+        for orient in ["split", "index", "columns"]:
+            inp = StringIO(df.to_json(orient=orient))
+            left = read_json(inp, orient=orient, convert_axes=False)
+            tm.assert_frame_equal(left, right)
+
+        right.index = RangeIndex(len(df))
+        inp = StringIO(df.to_json(orient="records"))
+        left = read_json(inp, orient="records", convert_axes=False)
+        tm.assert_frame_equal(left, right)
+
+        right.columns = RangeIndex(df.shape[1])
+        inp = StringIO(df.to_json(orient="values"))
+        left = read_json(inp, orient="values", convert_axes=False)
+        tm.assert_frame_equal(left, right)
+
+    def test_v12_compat(self, datapath):
+        dti = date_range("2000-01-03", "2000-01-07", unit="ns")
+        # freq doesn't roundtrip
+        dti = DatetimeIndex(np.asarray(dti), freq=None)
+        df = DataFrame(
+            [
+                [1.56808523, 0.65727391, 1.81021139, -0.17251653],
+                [-0.2550111, -0.08072427, -0.03202878, -0.17581665],
+                [1.51493992, 0.11805825, 1.629455, -1.31506612],
+                [-0.02765498, 0.44679743, 0.33192641, -0.27885413],
+                [0.05951614, -2.69652057, 1.28163262, 0.34703478],
+            ],
+            columns=["A", "B", "C", "D"],
+            index=dti,
+        )
+        df["date"] = Timestamp("19920106 18:21:32.12").as_unit("ns")
+        df.iloc[3, df.columns.get_loc("date")] = Timestamp("20130101")
+        df["modified"] = df["date"]
+        df.iloc[1, df.columns.get_loc("modified")] = pd.NaT
+
+        dirpath = datapath("io", "json", "data")
+        v12_json = os.path.join(dirpath, "tsframe_v012.json")
+        result = read_json(v12_json)
+        expected = df.copy()
+        expected["date"] = expected["date"].dt.as_unit("ns")
+        expected["modified"] = expected["modified"].dt.as_unit("ns")
+        expected.index = expected.index.as_unit("ns")
+        tm.assert_frame_equal(result, expected)
+
+        v12_iso_json = os.path.join(dirpath, "tsframe_iso_v012.json")
+        result_iso = read_json(v12_iso_json)
+        expected_iso = df.drop(["modified"], axis=1)
+        expected_iso["date"] = expected_iso["date"].dt.as_unit("us")
+        expected_iso.index = expected_iso.index.as_unit("us")
+        tm.assert_frame_equal(result_iso, expected_iso, check_column_type=False)
+
+    def test_blocks_compat_GH9037(self, using_infer_string):
+        index = date_range("20000101", periods=10, freq="h", unit="ns")
+        # freq doesn't round-trip
+        index = DatetimeIndex(list(index), freq=None)
+
+        df_mixed = DataFrame(
+            {
+                "float_1": [
+                    -0.92077639,
+                    0.77434435,
+                    1.25234727,
+                    0.61485564,
+                    -0.60316077,
+                    0.24653374,
+                    0.28668979,
+                    -2.51969012,
+                    0.95748401,
+                    -1.02970536,
+                ],
+                "int_1": [
+                    19680418,
+                    75337055,
+                    99973684,
+                    65103179,
+                    79373900,
+                    40314334,
+                    21290235,
+                    4991321,
+                    41903419,
+                    16008365,
+                ],
+                "str_1": [
+                    "78c608f1",
+                    "64a99743",
+                    "13d2ff52",
+                    "ca7f4af2",
+                    "97236474",
+                    "bde7e214",
+                    "1a6bde47",
+                    "b1190be5",
+                    "7a669144",
+                    "8d64d068",
+                ],
+                "float_2": [
+                    -0.0428278,
+                    -1.80872357,
+                    3.36042349,
+                    -0.7573685,
+                    -0.48217572,
+                    0.86229683,
+                    1.08935819,
+                    0.93898739,
+                    -0.03030452,
+                    1.43366348,
+                ],
+                "str_2": [
+                    "14f04af9",
+                    "d085da90",
+                    "4bcfac83",
+                    "81504caf",
+                    "2ffef4a9",
+                    "08e2f5c4",
+                    "07e1af03",
+                    "addbd4a7",
+                    "1f6a09ba",
+                    "4bfc4d87",
+                ],
+                "int_2": [
+                    86967717,
+                    98098830,
+                    51927505,
+                    20372254,
+                    12601730,
+                    20884027,
+                    34193846,
+                    10561746,
+                    24867120,
+                    76131025,
+                ],
+            },
+            index=index,
+        )
+
+        # JSON deserialisation always creates unicode strings
+        df_mixed.columns = df_mixed.columns.astype(
+            np.str_ if not using_infer_string else "str"
+        )
+        data = StringIO(df_mixed.to_json(orient="split"))
+        df_roundtrip = read_json(data, orient="split")
+        df_mixed.index = df_mixed.index.as_unit("ms")
+        tm.assert_frame_equal(
+            df_mixed,
+            df_roundtrip,
+            check_index_type=True,
+            check_column_type=True,
+            by_blocks=True,
+            check_exact=True,
+        )
+
+    def test_frame_nonprintable_bytes(self):
+        # GH14256: failing column caused segfaults, if it is not the last one
+
+        class BinaryThing:
+            def __init__(self, hexed) -> None:
+                self.hexed = hexed
+                self.binary = bytes.fromhex(hexed)
+
+            def __str__(self) -> str:
+                return self.hexed
+
+        hexed = "574b4454ba8c5eb4f98a8f45"
+        binthing = BinaryThing(hexed)
+
+        # verify the proper conversion of printable content
+        df_printable = DataFrame({"A": [binthing.hexed]})
+        assert df_printable.to_json() == f'{{"A":{{"0":"{hexed}"}}}}'
+
+        # check if non-printable content throws appropriate Exception
+        df_nonprintable = DataFrame({"A": [binthing]})
+        msg = "Unsupported UTF-8 sequence length when encoding string"
+        with pytest.raises(OverflowError, match=msg):
+            df_nonprintable.to_json()
+
+        # the same with multiple columns threw segfaults
+        df_mixed = DataFrame({"A": [binthing], "B": [1]}, columns=["A", "B"])
+        with pytest.raises(OverflowError, match=msg):
+            df_mixed.to_json()
+
+        # default_handler should resolve exceptions for non-string types
+        result = df_nonprintable.to_json(default_handler=str)
+        expected = f'{{"A":{{"0":"{hexed}"}}}}'
+        assert result == expected
+        assert (
+            df_mixed.to_json(default_handler=str)
+            == f'{{"A":{{"0":"{hexed}"}},"B":{{"0":1}}}}'
+        )
+
+    def test_label_overflow(self):
+        # GH14256: buffer length not checked when writing label
+        result = DataFrame({"bar" * 100000: [1], "foo": [1337]}).to_json()
+        expected = f'{{"{"bar" * 100000}":{{"0":1}},"foo":{{"0":1337}}}}'
+        assert result == expected
+
+    def test_series_non_unique_index(self):
+        s = Series(["a", "b"], index=[1, 1])
+
+        msg = "Series index must be unique for orient='index'"
+        with pytest.raises(ValueError, match=msg):
+            s.to_json(orient="index")
+
+        tm.assert_series_equal(
+            s,
+            read_json(
+                StringIO(s.to_json(orient="split")), orient="split", typ="series"
+            ),
+        )
+        unserialized = read_json(
+            StringIO(s.to_json(orient="records")), orient="records", typ="series"
+        )
+        tm.assert_equal(s.values, unserialized.values)
+
+    def test_series_default_orient(self, string_series):
+        assert string_series.to_json() == string_series.to_json(orient="index")
+
+    def test_series_roundtrip_simple(self, orient, string_series, using_infer_string):
+        data = StringIO(string_series.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient)
+
+        expected = string_series
+        if using_infer_string and orient in ("split", "index", "columns"):
+            # These schemas don't contain dtypes, so we infer string
+            expected.index = expected.index.astype("str")
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        if orient != "split":
+            expected.name = None
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [False, None])
+    def test_series_roundtrip_object(self, orient, dtype, object_series):
+        data = StringIO(object_series.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient, dtype=dtype)
+
+        expected = object_series
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        if orient != "split":
+            expected.name = None
+
+        if using_string_dtype():
+            expected = expected.astype("str")
+
+        tm.assert_series_equal(result, expected)
+
+    def test_series_roundtrip_empty(self, orient):
+        empty_series = Series([], index=[], dtype=np.float64)
+        data = StringIO(empty_series.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient)
+
+        expected = empty_series.reset_index(drop=True)
+        if orient in ("split"):
+            expected.index = expected.index.astype(np.float64)
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype_backend", [None, pytest.param("pyarrow", marks=td.skip_if_no("pyarrow"))]
+    )
+    def test_series_roundtrip_timeseries(self, dtype_backend, orient, datetime_series):
+        expected = datetime_series.copy()
+        if dtype_backend is not None:
+            datetime_series.index = Series(datetime_series.index).convert_dtypes(
+                dtype_backend=dtype_backend
+            )
+
+        data = StringIO(datetime_series.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient)
+
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        else:
+            expected.index = expected.index.as_unit("ms")
+        if orient != "split":
+            expected.name = None
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [np.float64, int])
+    def test_series_roundtrip_numeric(self, orient, dtype):
+        s = Series(range(6), index=["a", "b", "c", "d", "e", "f"])
+        data = StringIO(s.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient)
+
+        expected = s.copy()
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_series_to_json_except(self):
+        s = Series([1, 2, 3])
+        msg = "Invalid value 'garbage' for option 'orient'"
+        with pytest.raises(ValueError, match=msg):
+            s.to_json(orient="garbage")
+
+    def test_series_from_json_precise_float(self):
+        s = Series([4.56, 4.56, 4.56])
+        result = read_json(StringIO(s.to_json()), typ="series", precise_float=True)
+        tm.assert_series_equal(result, s, check_index_type=False)
+
+    def test_series_with_dtype(self):
+        # GH 21986
+        s = Series([4.56, 4.56, 4.56])
+        result = read_json(StringIO(s.to_json()), typ="series", dtype=np.int64)
+        expected = Series([4] * 3)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype_backend", [None, pytest.param("pyarrow", marks=td.skip_if_no("pyarrow"))]
+    )
+    @pytest.mark.parametrize(
+        "dtype,expected",
+        [
+            (True, Series(["2000-01-01"], dtype="datetime64[ms]")),
+            (False, Series([946684800000])),
+        ],
+    )
+    def test_series_with_dtype_datetime(self, dtype, expected, dtype_backend):
+        s = Series(["2000-01-01"], dtype="datetime64[ns]")
+        if dtype_backend is not None:
+            s = s.convert_dtypes(dtype_backend=dtype_backend)
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            data = StringIO(s.to_json())
+        result = read_json(data, typ="series", dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_frame_from_json_precise_float(self):
+        df = DataFrame([[4.56, 4.56, 4.56], [4.56, 4.56, 4.56]])
+        result = read_json(StringIO(df.to_json()), precise_float=True)
+        tm.assert_frame_equal(result, df)
+
+    def test_typ(self):
+        s = Series(range(6), index=["a", "b", "c", "d", "e", "f"], dtype="int64")
+        result = read_json(StringIO(s.to_json()), typ="series")
+        tm.assert_series_equal(result, s)
+
+    def test_reconstruction_index(self):
+        df = DataFrame([[1, 2, 3], [4, 5, 6]])
+        result = read_json(StringIO(df.to_json()))
+        tm.assert_frame_equal(result, df)
+
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=["A", "B", "C"])
+        result = read_json(StringIO(df.to_json()))
+        tm.assert_frame_equal(result, df)
+
+    def test_path(self, float_frame, int_frame, datetime_frame, temp_file):
+        for df in [float_frame, int_frame, datetime_frame]:
+            df.to_json(temp_file)
+            read_json(temp_file)
+
+    def test_axis_dates(self, datetime_series, datetime_frame):
+        # frame
+        json = StringIO(datetime_frame.to_json())
+        result = read_json(json)
+        expected = datetime_frame.copy()
+        expected.index = expected.index.as_unit("ms")
+        tm.assert_frame_equal(result, expected)
+
+        # series
+        json = StringIO(datetime_series.to_json())
+        result = read_json(json, typ="series")
+        expected = datetime_series.copy()
+        expected.index = expected.index.as_unit("ms")
+        tm.assert_series_equal(result, expected, check_names=False)
+        assert result.name is None
+
+    def test_convert_dates(self, datetime_series, datetime_frame):
+        # frame
+        df = datetime_frame
+        df["date"] = Timestamp("20130101").as_unit("ns")
+
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            json = StringIO(df.to_json())
+        result = read_json(json)
+        expected = df.copy()
+        expected["date"] = expected["date"].dt.as_unit("ms")
+        expected.index = expected.index.as_unit("ms")
+        tm.assert_frame_equal(result, expected)
+
+        df["foo"] = 1.0
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            json = StringIO(df.to_json(date_unit="ns"))
+
+        result = read_json(json, convert_dates=False)
+        expected = df.copy()
+        expected["date"] = expected["date"].values.view("i8")
+        expected["foo"] = expected["foo"].astype("int64")
+        tm.assert_frame_equal(result, expected)
+
+        # series
+        ts = Series(Timestamp("20130101").as_unit("ns"), index=datetime_series.index)
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            json = StringIO(ts.to_json())
+        result = read_json(json, typ="series")
+        expected = ts.dt.as_unit("ms")
+        expected.index = expected.index.as_unit("ms")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("date_format", ["epoch", "iso"])
+    @pytest.mark.parametrize("as_object", [True, False])
+    @pytest.mark.parametrize("date_typ", [datetime.date, datetime.datetime, Timestamp])
+    def test_date_index_and_values(self, date_format, as_object, date_typ):
+        data = [date_typ(year=2020, month=1, day=1), pd.NaT]
+        if as_object:
+            data.append("a")
+
+        ser = Series(data, index=data)
+        if not as_object:
+            ser = ser.astype("M8[ns]")
+            if isinstance(ser.index, DatetimeIndex):
+                ser.index = ser.index.as_unit("ns")
+
+        expected_warning = None
+        if date_format == "epoch":
+            expected = '{"1577836800000":1577836800000,"null":null}'
+            expected_warning = Pandas4Warning
+        else:
+            expected = (
+                '{"2020-01-01T00:00:00.000":"2020-01-01T00:00:00.000","null":null}'
+            )
+
+        msg = (
+            "'epoch' date format is deprecated and will be removed in a future "
+            "version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(expected_warning, match=msg):
+            result = ser.to_json(date_format=date_format)
+
+        if as_object:
+            expected = expected.replace("}", ',"a":"a"}')
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "infer_word",
+        [
+            "trade_time",
+            "date",
+            "datetime",
+            "sold_at",
+            "modified",
+            "timestamp",
+            "timestamps",
+        ],
+    )
+    def test_convert_dates_infer(self, infer_word):
+        # GH10747
+
+        data = [{"id": 1, infer_word: 1036713600000}, {"id": 2}]
+        expected = DataFrame(
+            [[1, Timestamp("2002-11-08")], [2, pd.NaT]], columns=["id", infer_word]
+        )
+        expected[infer_word] = expected[infer_word].astype("M8[ms]")
+
+        result = read_json(StringIO(ujson_dumps(data)))[["id", infer_word]]
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "date,date_unit",
+        [
+            ("20130101 20:43:42.123", None),
+            ("20130101 20:43:42", "s"),
+            ("20130101 20:43:42.123", "ms"),
+            ("20130101 20:43:42.123456", "us"),
+            ("20130101 20:43:42.123456789", "ns"),
+        ],
+    )
+    def test_date_format_frame(self, date, date_unit, datetime_frame):
+        df = datetime_frame
+
+        df["date"] = Timestamp(date).as_unit("ns")
+        df.iloc[1, df.columns.get_loc("date")] = pd.NaT
+        df.iloc[5, df.columns.get_loc("date")] = pd.NaT
+        if date_unit:
+            json = df.to_json(date_format="iso", date_unit=date_unit)
+        else:
+            json = df.to_json(date_format="iso")
+
+        result = read_json(StringIO(json))
+        expected = df.copy()
+        if date_unit != "ns":
+            expected["date"] = expected["date"].dt.as_unit("us")
+            expected.index = expected.index.as_unit("us")
+        tm.assert_frame_equal(result, expected)
+
+    def test_date_format_frame_raises(self, datetime_frame):
+        df = datetime_frame
+        msg = "Invalid value 'foo' for option 'date_unit'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(date_format="iso", date_unit="foo")
+
+    @pytest.mark.parametrize(
+        "date,date_unit",
+        [
+            ("20130101 20:43:42.123", None),
+            ("20130101 20:43:42", "s"),
+            ("20130101 20:43:42.123", "ms"),
+            ("20130101 20:43:42.123456", "us"),
+            ("20130101 20:43:42.123456789", "ns"),
+        ],
+    )
+    def test_date_format_series(self, date, date_unit, datetime_series):
+        ts = Series(Timestamp(date), index=datetime_series.index)
+        ts.iloc[1] = pd.NaT
+        ts.iloc[5] = pd.NaT
+        if date_unit:
+            json = ts.to_json(date_format="iso", date_unit=date_unit)
+        else:
+            json = ts.to_json(date_format="iso")
+
+        result = read_json(StringIO(json), typ="series")
+        expected = ts.copy()
+        if date_unit != "ns":
+            expected.index = expected.index.as_unit("us")
+        tm.assert_series_equal(result, expected)
+
+    def test_date_format_series_raises(self, datetime_series):
+        ts = Series(Timestamp("20130101 20:43:42.123"), index=datetime_series.index)
+        msg = "Invalid value 'foo' for option 'date_unit'"
+        with pytest.raises(ValueError, match=msg):
+            ts.to_json(date_format="iso", date_unit="foo")
+
+    def test_date_unit(self, unit, datetime_frame):
+        df = datetime_frame
+        df["date"] = Timestamp("20130101 20:43:42").as_unit("ns")
+        dl = df.columns.get_loc("date")
+        df.iloc[1, dl] = Timestamp("19710101 20:43:42")
+        df.iloc[2, dl] = Timestamp("21460101 20:43:42")
+        df.iloc[4, dl] = pd.NaT
+
+        msg = (
+            "'epoch' date format is deprecated and will be removed in a future "
+            "version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            json = df.to_json(date_format="epoch", date_unit=unit)
+
+        # force date unit
+        # result = read_json(StringIO(json), date_unit=unit)
+        expected = df.copy()
+        expected["date"] = expected["date"].dt.as_unit(unit)
+        expected.index = expected.index.as_unit(unit)
+        # tm.assert_frame_equal(result, expected)
+
+        # detect date unit
+        result = read_json(StringIO(json), date_unit=None)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "df, warn",
+        [
+            (DataFrame({"A": ["a", "b", "c"], "B": np.arange(3)}), None),
+            (DataFrame({"A": [True, False, False]}), None),
+            (
+                DataFrame(
+                    {"A": ["a", "b", "c"], "B": pd.to_timedelta(np.arange(3), unit="D")}
+                ),
+                Pandas4Warning,
+            ),
+            (
+                DataFrame(
+                    {"A": pd.to_datetime(["2020-01-01", "2020-02-01", "2020-03-01"])}
+                ),
+                Pandas4Warning,
+            ),
+        ],
+    )
+    def test_default_epoch_date_format_deprecated(self, df, warn):
+        # GH 57063
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(warn, match=msg):
+            df.to_json()
+
+    @pytest.mark.parametrize(
+        "dtype_backend", [None, pytest.param("pyarrow", marks=td.skip_if_no("pyarrow"))]
+    )
+    @pytest.mark.parametrize("unit", ["s", "ms", "us"])
+    def test_iso_non_nano_datetimes(self, dtype_backend, unit):
+        # Test that numpy datetimes
+        # in an Index or a column with non-nano resolution can be serialized
+        # correctly
+        # GH53686
+        index = DatetimeIndex(
+            [np.datetime64("2023-01-01T11:22:33.123456", unit)],
+            dtype=f"datetime64[{unit}]",
+        )
+        df = DataFrame(
+            {
+                "date": Series(
+                    [np.datetime64("2022-01-01T11:22:33.123456", unit)],
+                    dtype=f"datetime64[{unit}]",
+                    index=index,
+                ),
+                "date_obj": Series(
+                    [np.datetime64("2023-01-01T11:22:33.123456", unit)],
+                    dtype=object,
+                    index=index,
+                ),
+            },
+        )
+        expected = df.copy()
+        expected.index = expected.index.as_unit("us")
+        expected["date"] = expected["date"].dt.as_unit("us")
+        expected["date_obj"] = expected["date_obj"].astype("datetime64[us]")
+
+        if dtype_backend is not None:
+            df = df.convert_dtypes(dtype_backend=dtype_backend)
+
+        json = df.to_json(date_format="iso", date_unit=unit)
+        result = read_json(StringIO(json), convert_dates=["date", "date_obj"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_weird_nested_json(self):
+        # this used to core dump the parser
+        s = r"""{
+        "status": "success",
+        "data": {
+        "posts": [
+            {
+            "id": 1,
+            "title": "A blog post",
+            "body": "Some useful content"
+            },
+            {
+            "id": 2,
+            "title": "Another blog post",
+            "body": "More content"
+            }
+           ]
+          }
+        }"""
+        read_json(StringIO(s))
+
+    def test_doc_example(self):
+        dfj2 = DataFrame(
+            np.random.default_rng(2).standard_normal((5, 2)), columns=list("AB")
+        )
+        dfj2["date"] = Timestamp("20130101")
+        dfj2["ints"] = range(5)
+        dfj2["bools"] = True
+        dfj2.index = date_range("20130101", periods=5, unit="ns")
+
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            json = StringIO(dfj2.to_json())
+        result = read_json(json, dtype={"ints": np.int64, "bools": np.bool_})
+        tm.assert_frame_equal(result, result)
+
+    def test_round_trip_exception(self, datapath):
+        # GH 3867
+        path = datapath("io", "json", "data", "teams.csv")
+        df = pd.read_csv(path)
+        s = df.to_json()
+
+        result = read_json(StringIO(s))
+        res = result.reindex(index=df.index, columns=df.columns)
+        res = res.fillna(np.nan)
+        tm.assert_frame_equal(res, df)
+
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    def test_url(self, httpserver):
+        data = '{"created_at": ["2023-06-23T18:21:36Z"], "closed_at": ["2023-06-23T18:21:36"], "updated_at": ["2023-06-23T18:21:36Z"]}\n'  # noqa: E501
+        httpserver.serve_content(content=data)
+        result = read_json(httpserver.url, convert_dates=True)
+        for field, dtype in [
+            ["created_at", pd.DatetimeTZDtype("us", tz="UTC")],
+            ["closed_at", "datetime64[us]"],
+            ["updated_at", pd.DatetimeTZDtype("us", tz="UTC")],
+        ]:
+            assert result[field].dtype == dtype
+
+    def test_timedelta(self, unit):
+        converter = lambda x: pd.to_timedelta(x, unit="ms")
+
+        ser = Series([timedelta(23), timedelta(seconds=5)], dtype=f"m8[{unit}]")
+        assert ser.dtype == f"timedelta64[{unit}]"
+
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            result = read_json(StringIO(ser.to_json()), typ="series").apply(converter)
+        tm.assert_series_equal(result, ser.astype("m8[ms]"))
+
+        ser = Series(
+            [timedelta(23), timedelta(seconds=5)], index=Index([0, 1]), dtype="m8[ns]"
+        )
+        assert ser.dtype == "timedelta64[ns]"
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            result = read_json(StringIO(ser.to_json()), typ="series").apply(converter)
+        tm.assert_series_equal(result, ser.astype("m8[ms]"))
+
+        frame = DataFrame([timedelta(23), timedelta(seconds=5)], dtype="m8[ns]")
+        assert frame[0].dtype == "timedelta64[ns]"
+
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            json = frame.to_json()
+        result = read_json(StringIO(json)).apply(converter)
+        tm.assert_frame_equal(frame.astype("m8[ms]"), result)
+
+    def test_timedelta2(self):
+        frame = DataFrame(
+            {
+                "a": [timedelta(days=23), timedelta(seconds=5)],
+                "b": [1, 2],
+                "c": date_range(start="20130101", periods=2, unit="ns"),
+            }
+        )
+        frame["a"] = frame["a"].astype("m8[ns]")
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            data = StringIO(frame.to_json(date_unit="ns"))
+        result = read_json(data)
+        result["a"] = pd.to_timedelta(result.a, unit="ns")
+        result["c"] = pd.to_datetime(result.c)
+        tm.assert_frame_equal(frame, result)
+
+    def test_mixed_timedelta_datetime(self):
+        td = timedelta(23)
+        ts = Timestamp("20130101")
+        frame = DataFrame({"a": [td, ts]}, dtype=object)
+
+        expected = DataFrame(
+            {"a": [pd.Timedelta(td).as_unit("ns")._value, ts.as_unit("ns")._value]}
+        )
+        data = StringIO(frame.to_json(date_unit="ns"))
+        result = read_json(data, dtype={"a": "int64"})
+        tm.assert_frame_equal(result, expected, check_index_type=False)
+
+    @pytest.mark.parametrize("as_object", [True, False])
+    @pytest.mark.parametrize("date_format", ["iso", "epoch"])
+    @pytest.mark.parametrize("timedelta_typ", [pd.Timedelta, timedelta])
+    def test_timedelta_to_json(self, as_object, date_format, timedelta_typ):
+        # GH28156: to_json not correctly formatting Timedelta
+        data = [timedelta_typ(days=1), timedelta_typ(days=2), pd.NaT]
+        if as_object:
+            data.append("a")
+
+        ser = Series(data, index=data)
+        if not as_object:
+            ser = ser.astype("m8[ns]")
+            ser.index = ser.index.astype("m8[ns]")
+        expected_warning = None
+        if date_format == "iso":
+            expected = (
+                '{"P1DT0H0M0S":"P1DT0H0M0S","P2DT0H0M0S":"P2DT0H0M0S","null":null}'
+            )
+        else:
+            expected_warning = Pandas4Warning
+            expected = '{"86400000":86400000,"172800000":172800000,"null":null}'
+
+        if as_object:
+            expected = expected.replace("}", ',"a":"a"}')
+
+        msg = (
+            "'epoch' date format is deprecated and will be removed in a future "
+            "version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(expected_warning, match=msg):
+            result = ser.to_json(date_format=date_format)
+        assert result == expected
+
+    @pytest.mark.parametrize("as_object", [True, False])
+    @pytest.mark.parametrize("timedelta_typ", [pd.Timedelta, timedelta])
+    def test_timedelta_to_json_fractional_precision(self, as_object, timedelta_typ):
+        data = [timedelta_typ(milliseconds=42)]
+        ser = Series(data, index=data).astype("m8[ns]")
+        ser.index = ser.index.astype("m8[ns]")
+        warn = Pandas4Warning
+        if as_object:
+            ser = ser.astype(object)
+            warn = None
+
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(warn, match=msg):
+            result = ser.to_json()
+        expected = '{"42":42}'
+        assert result == expected
+
+    def test_default_handler(self):
+        value = object()
+        frame = DataFrame({"a": [7, value]})
+        expected = DataFrame({"a": [7, str(value)]})
+        result = read_json(StringIO(frame.to_json(default_handler=str)))
+        tm.assert_frame_equal(expected, result, check_index_type=False)
+
+    def test_default_handler_indirect(self):
+        def default(obj):
+            if isinstance(obj, complex):
+                return [("mathjs", "Complex"), ("re", obj.real), ("im", obj.imag)]
+            return str(obj)
+
+        df_list = [
+            9,
+            DataFrame(
+                {"a": [1, "STR", complex(4, -5)], "b": [float("nan"), None, "N/A"]},
+                columns=["a", "b"],
+            ),
+        ]
+        expected = (
+            '[9,[[1,null],["STR",null],[[["mathjs","Complex"],'
+            '["re",4.0],["im",-5.0]],"N\\/A"]]]'
+        )
+        assert (
+            ujson_dumps(df_list, default_handler=default, orient="values") == expected
+        )
+
+    def test_default_handler_numpy_unsupported_dtype(self):
+        # GH12554 to_json raises 'Unhandled numpy dtype 15'
+        df = DataFrame(
+            {"a": [1, 2.3, complex(4, -5)], "b": [float("nan"), None, complex(1.2, 0)]},
+            columns=["a", "b"],
+        )
+        expected = (
+            '[["(1+0j)","(nan+0j)"],["(2.3+0j)","(nan+0j)"],["(4-5j)","(1.2+0j)"]]'
+        )
+        assert df.to_json(default_handler=str, orient="values") == expected
+
+    def test_default_handler_raises(self):
+        msg = "raisin"
+
+        def my_handler_raises(obj):
+            raise TypeError(msg)
+
+        with pytest.raises(TypeError, match=msg):
+            DataFrame({"a": [1, 2, object()]}).to_json(
+                default_handler=my_handler_raises
+            )
+        with pytest.raises(TypeError, match=msg):
+            DataFrame({"a": [1, 2, complex(4, -5)]}).to_json(
+                default_handler=my_handler_raises
+            )
+
+    def test_categorical(self):
+        # GH4377 df.to_json segfaults with non-ndarray blocks
+        df = DataFrame({"A": ["a", "b", "c", "a", "b", "b", "a"]})
+        df["B"] = df["A"]
+        expected = df.to_json()
+
+        df["B"] = df["A"].astype("category")
+        assert expected == df.to_json()
+
+        s = df["A"]
+        sc = df["B"]
+        assert s.to_json() == sc.to_json()
+
+    def test_datetime_tz(self):
+        # GH4377 df.to_json segfaults with non-ndarray blocks
+        tz_range = date_range("20130101", periods=3, tz="US/Eastern", unit="ns")
+        tz_naive = tz_range.tz_convert("utc").tz_localize(None)
+
+        df = DataFrame(
+            {"A": tz_range, "B": date_range("20130101", periods=3, unit="ns")}
+        )
+
+        df_naive = df.copy()
+        df_naive["A"] = tz_naive
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            expected = df_naive.to_json()
+            assert expected == df.to_json()
+
+        stz = Series(tz_range)
+        s_naive = Series(tz_naive)
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            assert stz.to_json() == s_naive.to_json()
+
+    def test_sparse(self):
+        # GH4377 df.to_json segfaults with non-ndarray blocks
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
+        df.loc[:8] = np.nan
+
+        sdf = df.astype("Sparse")
+        expected = df.to_json()
+        assert expected == sdf.to_json()
+
+        s = Series(np.random.default_rng(2).standard_normal(10))
+        s.loc[:8] = np.nan
+        ss = s.astype("Sparse")
+
+        expected = s.to_json()
+        assert expected == ss.to_json()
+
+    @pytest.mark.parametrize(
+        "ts",
+        [
+            Timestamp("2013-01-10 05:00:00Z"),
+            Timestamp("2013-01-10 00:00:00", tz="US/Eastern"),
+            Timestamp("2013-01-10 00:00:00-0500"),
+        ],
+    )
+    def test_tz_is_utc(self, ts):
+        exp = '"2013-01-10T05:00:00.000Z"'
+
+        assert ujson_dumps(ts, iso_dates=True) == exp
+        dt = ts.to_pydatetime()
+        assert ujson_dumps(dt, iso_dates=True) == exp
+
+    def test_tz_is_naive(self):
+        ts = Timestamp("2013-01-10 05:00:00")
+        exp = '"2013-01-10T05:00:00.000"'
+
+        assert ujson_dumps(ts, iso_dates=True) == exp
+        dt = ts.to_pydatetime()
+        assert ujson_dumps(dt, iso_dates=True) == exp
+
+    @pytest.mark.parametrize(
+        "tz_range",
+        [
+            date_range("2013-01-01 05:00:00Z", periods=2, unit="ns"),
+            date_range("2013-01-01 00:00:00", periods=2, tz="US/Eastern", unit="ns"),
+            date_range("2013-01-01 00:00:00-0500", periods=2, unit="ns"),
+        ],
+    )
+    def test_tz_range_is_utc(self, tz_range):
+        exp = '["2013-01-01T05:00:00.000Z","2013-01-02T05:00:00.000Z"]'
+        dfexp = '{"DT":{"0":"2013-01-01T05:00:00.000Z","1":"2013-01-02T05:00:00.000Z"}}'
+
+        assert ujson_dumps(tz_range, iso_dates=True) == exp
+        dti = DatetimeIndex(tz_range)
+        # Ensure datetimes in object array are serialized correctly
+        # in addition to the normal DTI case
+        assert ujson_dumps(dti, iso_dates=True) == exp
+        assert ujson_dumps(dti.astype(object), iso_dates=True) == exp
+        df = DataFrame({"DT": dti})
+        result = ujson_dumps(df, iso_dates=True)
+        assert result == dfexp
+        assert ujson_dumps(df.astype({"DT": object}), iso_dates=True)
+
+    def test_tz_range_is_naive(self):
+        dti = date_range("2013-01-01 05:00:00", periods=2, unit="ns")
+
+        exp = '["2013-01-01T05:00:00.000","2013-01-02T05:00:00.000"]'
+        dfexp = '{"DT":{"0":"2013-01-01T05:00:00.000","1":"2013-01-02T05:00:00.000"}}'
+
+        # Ensure datetimes in object array are serialized correctly
+        # in addition to the normal DTI case
+        assert ujson_dumps(dti, iso_dates=True) == exp
+        assert ujson_dumps(dti.astype(object), iso_dates=True) == exp
+        df = DataFrame({"DT": dti})
+        result = ujson_dumps(df, iso_dates=True)
+        assert result == dfexp
+        assert ujson_dumps(df.astype({"DT": object}), iso_dates=True)
+
+    def test_read_inline_jsonl(self):
+        # GH9180
+
+        result = read_json(StringIO('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n'), lines=True)
+        expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.single_cpu
+    @pytest.mark.network
+    @td.skip_if_not_us_locale
+    def test_read_s3_jsonl(self, s3_bucket_public_with_data, s3so):
+        # GH17200
+        result = read_json(
+            f"s3n://{s3_bucket_public_with_data.name}/items.jsonl",
+            lines=True,
+            storage_options=s3so,
+        )
+        expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_read_local_jsonl(self, temp_file):
+        # GH17200
+        with open(temp_file, "w", encoding="utf-8") as infile:
+            infile.write('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n')
+        result = read_json(temp_file, lines=True)
+        expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_read_jsonl_unicode_chars(self):
+        # GH15132: non-ascii unicode characters
+        # \u201d == RIGHT DOUBLE QUOTATION MARK
+
+        # simulate file handle
+        json = '{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n'
+        json = StringIO(json)
+        result = read_json(json, lines=True)
+        expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+        # simulate string
+        json = StringIO('{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n')
+        result = read_json(json, lines=True)
+        expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("bigNum", [sys.maxsize + 1, -(sys.maxsize + 2)])
+    def test_to_json_large_numbers(self, bigNum):
+        # GH34473
+        series = Series(bigNum, dtype=object, index=["articleId"])
+        json = series.to_json()
+        expected = '{"articleId":' + str(bigNum) + "}"
+        assert json == expected
+
+        df = DataFrame(bigNum, dtype=object, index=["articleId"], columns=[0])
+        json = df.to_json()
+        expected = '{"0":{"articleId":' + str(bigNum) + "}}"
+        assert json == expected
+
+    @pytest.mark.parametrize("bigNum", [-(2**63) - 1, 2**64])
+    def test_read_json_large_numbers(self, bigNum):
+        # GH20599, 26068
+        json = StringIO('{"articleId":' + str(bigNum) + "}")
+        msg = r"Value is too small|Value is too big"
+        with pytest.raises(ValueError, match=msg):
+            read_json(json)
+
+        json = StringIO('{"0":{"articleId":' + str(bigNum) + "}}")
+        with pytest.raises(ValueError, match=msg):
+            read_json(json)
+
+    def test_read_json_large_numbers2(self):
+        # GH18842
+        json = '{"articleId": "1404366058080022500245"}'
+        json = StringIO(json)
+        result = read_json(json, typ="series")
+        expected = Series(1.404366e21, index=["articleId"])
+        tm.assert_series_equal(result, expected)
+
+        json = '{"0": {"articleId": "1404366058080022500245"}}'
+        json = StringIO(json)
+        result = read_json(json)
+        expected = DataFrame(1.404366e21, index=["articleId"], columns=[0])
+        tm.assert_frame_equal(result, expected)
+
+    def test_to_jsonl(self):
+        # GH9180
+        df = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+        result = df.to_json(orient="records", lines=True)
+        expected = '{"a":1,"b":2}\n{"a":1,"b":2}\n'
+        assert result == expected
+
+        df = DataFrame([["foo}", "bar"], ['foo"', "bar"]], columns=["a", "b"])
+        result = df.to_json(orient="records", lines=True)
+        expected = '{"a":"foo}","b":"bar"}\n{"a":"foo\\"","b":"bar"}\n'
+        assert result == expected
+        tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
+
+        # GH15096: escaped characters in columns and data
+        df = DataFrame([["foo\\", "bar"], ['foo"', "bar"]], columns=["a\\", "b"])
+        result = df.to_json(orient="records", lines=True)
+        expected = '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}\n'
+        assert result == expected
+
+        tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
+
+    # TODO: there is a near-identical test for pytables; can we share?
+    @pytest.mark.xfail(reason="GH#13774 encoding kwarg not supported", raises=TypeError)
+    @pytest.mark.parametrize(
+        "val",
+        [
+            [b"E\xc9, 17", b"", b"a", b"b", b"c"],
+            [b"E\xc9, 17", b"a", b"b", b"c"],
+            [b"EE, 17", b"", b"a", b"b", b"c"],
+            [b"E\xc9, 17", b"\xf8\xfc", b"a", b"b", b"c"],
+            [b"", b"a", b"b", b"c"],
+            [b"\xf8\xfc", b"a", b"b", b"c"],
+            [b"A\xf8\xfc", b"", b"a", b"b", b"c"],
+            [np.nan, b"", b"b", b"c"],
+            [b"A\xf8\xfc", np.nan, b"", b"b", b"c"],
+        ],
+    )
+    @pytest.mark.parametrize("dtype", ["category", object])
+    def test_latin_encoding(self, dtype, val, temp_file):
+        # GH 13774
+        ser = Series(
+            [x.decode("latin-1") if isinstance(x, bytes) else x for x in val],
+            dtype=dtype,
+        )
+        encoding = "latin-1"
+        ser.to_json(temp_file, encoding=encoding)
+        retr = read_json(StringIO(temp_file), encoding=encoding)
+        tm.assert_series_equal(ser, retr, check_categorical=False)
+
+    def test_data_frame_size_after_to_json(self):
+        # GH15344
+        df = DataFrame({"a": [str(1)]})
+
+        size_before = df.memory_usage(index=True, deep=True).sum()
+        df.to_json()
+        size_after = df.memory_usage(index=True, deep=True).sum()
+
+        assert size_before == size_after
+
+    @pytest.mark.parametrize(
+        "index", [None, [1, 2], [1.0, 2.0], ["a", "b"], ["1", "2"], ["1.", "2."]]
+    )
+    @pytest.mark.parametrize("columns", [["a", "b"], ["1", "2"], ["1.", "2."]])
+    def test_from_json_to_json_table_index_and_columns(self, index, columns):
+        # GH25433 GH25435
+        expected = DataFrame([[1, 2], [3, 4]], index=index, columns=columns)
+        dfjson = expected.to_json(orient="table")
+
+        result = read_json(StringIO(dfjson), orient="table")
+        tm.assert_frame_equal(result, expected)
+
+    def test_from_json_to_json_table_dtypes(self):
+        # GH21345
+        expected = DataFrame({"a": [1, 2], "b": [3.0, 4.0], "c": ["5", "6"]})
+        dfjson = expected.to_json(orient="table")
+        result = read_json(StringIO(dfjson), orient="table")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("orient", ["split", "records", "index", "columns"])
+    def test_to_json_from_json_columns_dtypes(self, orient, using_infer_string):
+        # GH21892 GH33205
+        expected = DataFrame.from_dict(
+            {
+                "Integer": Series([1, 2, 3], dtype="int64"),
+                "Float": Series([None, 2.0, 3.0], dtype="float64"),
+                "Object": Series([None, "", "c"], dtype="object"),
+                "Bool": Series([True, False, True], dtype="bool"),
+                "Category": Series(["a", "b", None], dtype="category"),
+                "Datetime": Series(
+                    ["2020-01-01", None, "2020-01-03"], dtype="datetime64[ms]"
+                ),
+            }
+        )
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(Pandas4Warning, match=msg):
+            dfjson = expected.to_json(orient=orient)
+
+        if using_infer_string:
+            # When this is read back in it is inferred to "str" dtype which
+            #  uses NaN instead of None.
+            expected.loc[0, "Object"] = np.nan
+
+        result = read_json(
+            StringIO(dfjson),
+            orient=orient,
+            dtype={
+                "Integer": "int64",
+                "Float": "float64",
+                "Object": "object",
+                "Bool": "bool",
+                "Category": "category",
+                "Datetime": "datetime64[ns]",
+            },
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_to_json_with_index_as_a_column_name(self):
+        df = DataFrame(data={"index": [1, 2], "a": [2, 3]})
+        with pytest.raises(
+            ValueError, match="Overlapping names between the index and columns"
+        ):
+            df.to_json(orient="table")
+
+    @pytest.mark.parametrize("dtype", [True, {"b": int, "c": int}])
+    def test_read_json_table_dtype_raises(self, dtype):
+        # GH21345
+        df = DataFrame({"a": [1, 2], "b": [3.0, 4.0], "c": ["5", "6"]})
+        dfjson = df.to_json(orient="table")
+        msg = "cannot pass both dtype and orient='table'"
+        with pytest.raises(ValueError, match=msg):
+            read_json(dfjson, orient="table", dtype=dtype)
+
+    @pytest.mark.parametrize("orient", ["index", "columns", "records", "values"])
+    def test_read_json_table_empty_axes_dtype(self, orient):
+        # GH28558
+
+        expected = DataFrame()
+        result = read_json(StringIO("{}"), orient=orient, convert_axes=True)
+        tm.assert_index_equal(result.index, expected.index)
+        tm.assert_index_equal(result.columns, expected.columns)
+
+    def test_read_json_table_convert_axes_raises(self):
+        # GH25433 GH25435
+        df = DataFrame([[1, 2], [3, 4]], index=[1.0, 2.0], columns=["1.", "2."])
+        dfjson = df.to_json(orient="table")
+        msg = "cannot pass both convert_axes and orient='table'"
+        with pytest.raises(ValueError, match=msg):
+            read_json(dfjson, orient="table", convert_axes=True)
+
+    @pytest.mark.parametrize(
+        "data, expected",
+        [
+            (
+                DataFrame([[1, 2], [4, 5]], columns=["a", "b"]),
+                {"columns": ["a", "b"], "data": [[1, 2], [4, 5]]},
+            ),
+            (
+                DataFrame([[1, 2], [4, 5]], columns=["a", "b"]).rename_axis("foo"),
+                {"columns": ["a", "b"], "data": [[1, 2], [4, 5]]},
+            ),
+            (
+                DataFrame(
+                    [[1, 2], [4, 5]], columns=["a", "b"], index=[["a", "b"], ["c", "d"]]
+                ),
+                {"columns": ["a", "b"], "data": [[1, 2], [4, 5]]},
+            ),
+            (Series([1, 2, 3], name="A"), {"name": "A", "data": [1, 2, 3]}),
+            (
+                Series([1, 2, 3], name="A").rename_axis("foo"),
+                {"name": "A", "data": [1, 2, 3]},
+            ),
+            (
+                Series([1, 2], name="A", index=[["a", "b"], ["c", "d"]]),
+                {"name": "A", "data": [1, 2]},
+            ),
+        ],
+    )
+    def test_index_false_to_json_split(self, data, expected):
+        # GH 17394
+        # Testing index=False in to_json with orient='split'
+
+        result = data.to_json(orient="split", index=False)
+        result = json.loads(result)
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            (DataFrame([[1, 2], [4, 5]], columns=["a", "b"])),
+            (DataFrame([[1, 2], [4, 5]], columns=["a", "b"]).rename_axis("foo")),
+            (
+                DataFrame(
+                    [[1, 2], [4, 5]], columns=["a", "b"], index=[["a", "b"], ["c", "d"]]
+                )
+            ),
+            (Series([1, 2, 3], name="A")),
+            (Series([1, 2, 3], name="A").rename_axis("foo")),
+            (Series([1, 2], name="A", index=[["a", "b"], ["c", "d"]])),
+        ],
+    )
+    def test_index_false_to_json_table(self, data):
+        # GH 17394
+        # Testing index=False in to_json with orient='table'
+
+        result = data.to_json(orient="table", index=False)
+        result = json.loads(result)
+
+        expected = {
+            "schema": pd.io.json.build_table_schema(data, index=False),
+            "data": DataFrame(data).to_dict(orient="records"),
+        }
+
+        assert result == expected
+
+    @pytest.mark.parametrize("orient", ["index", "columns"])
+    def test_index_false_error_to_json(self, orient):
+        # GH 17394, 25513
+        # Testing error message from to_json with index=False
+
+        df = DataFrame([[1, 2], [4, 5]], columns=["a", "b"])
+
+        msg = (
+            "'index=False' is only valid when 'orient' is 'split', "
+            "'table', 'records', or 'values'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient=orient, index=False)
+
+    @pytest.mark.parametrize("orient", ["records", "values"])
+    def test_index_true_error_to_json(self, orient):
+        # GH 25513
+        # Testing error message from to_json with index=True
+
+        df = DataFrame([[1, 2], [4, 5]], columns=["a", "b"])
+
+        msg = (
+            "'index=True' is only valid when 'orient' is 'split', "
+            "'table', 'index', or 'columns'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient=orient, index=True)
+
+    @pytest.mark.parametrize("orient", ["split", "table"])
+    @pytest.mark.parametrize("index", [True, False])
+    def test_index_false_from_json_to_json(self, orient, index):
+        # GH25170
+        # Test index=False in from_json to_json
+        expected = DataFrame({"a": [1, 2], "b": [3, 4]})
+        dfjson = expected.to_json(orient=orient, index=index)
+        result = read_json(StringIO(dfjson), orient=orient)
+        tm.assert_frame_equal(result, expected)
+
+    def test_read_timezone_information(self):
+        # GH 25546
+        result = read_json(
+            StringIO('{"2019-01-01T11:00:00.000Z":88}'), typ="series", orient="index"
+        )
+        exp_dti = DatetimeIndex(["2019-01-01 11:00:00"], dtype="M8[us, UTC]")
+        expected = Series([88], index=exp_dti)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "url",
+        [
+            "s3://example-fsspec/",
+            "gcs://another-fsspec/file.json",
+            "filecache::s3://yet-another-fsspec/file.json",
+            "https://example-site.com/data",
+            "some-protocol://data.txt",
+        ],
+    )
+    def test_read_json_with_url_value(self, url):
+        # GH 36271
+        result = read_json(StringIO(f'{{"url":{{"0":"{url}"}}}}'))
+        expected = DataFrame({"url": [url]})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "compression",
+        ["", ".gz", ".bz2", ".tar"],
+    )
+    def test_read_json_with_very_long_file_path(self, compression):
+        # GH 46718
+        long_json_path = f"{'a' * 1000}.json{compression}"
+        with pytest.raises(
+            FileNotFoundError, match=f"File {long_json_path} does not exist"
+        ):
+            # path too long for Windows is handled in file_exists() but raises in
+            # _get_data_from_filepath()
+            read_json(long_json_path)
+
+    @pytest.mark.parametrize(
+        "date_format,key", [("epoch", 86400000), ("iso", "1970-01-02T00:00:00.000")]
+    )
+    def test_datetime_as_label(self, date_format, key, unit):
+        df = DataFrame(
+            [[1]], columns=[(Timestamp(0) + pd.Timedelta("1D")).as_unit(unit)]
+        )
+        expected = f'{{"{key}":{{"0":1}}}}'
+
+        expected_warning = None
+        if date_format == "epoch":
+            expected_warning = Pandas4Warning
+
+        msg = (
+            "'epoch' date format is deprecated and will be removed in a future "
+            "version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(expected_warning, match=msg):
+            result = df.to_json(date_format=date_format)
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "date_format,key", [("epoch", 86400000), ("iso", "P1DT0H0M0S")]
+    )
+    def test_timedelta_as_label(self, date_format, key, unit):
+        df = DataFrame([[1]], columns=[pd.Timedelta("1D").as_unit(unit)])
+        expected = f'{{"{key}":{{"0":1}}}}'
+
+        expected_warning = None
+        if date_format == "epoch":
+            expected_warning = Pandas4Warning
+
+        msg = (
+            "'epoch' date format is deprecated and will be removed in a future "
+            "version, please use 'iso' date format instead."
+        )
+        with tm.assert_produces_warning(expected_warning, match=msg):
+            result = df.to_json(date_format=date_format)
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "orient,expected",
+        [
+            ("index", "{\"('a', 'b')\":{\"('c', 'd')\":1}}"),
+            ("columns", "{\"('c', 'd')\":{\"('a', 'b')\":1}}"),
+            # TODO: the below have separate encoding procedures
+            pytest.param(
+                "split",
+                "",
+                marks=pytest.mark.xfail(
+                    reason="Produces JSON but not in a consistent manner"
+                ),
+            ),
+            pytest.param(
+                "table",
+                "",
+                marks=pytest.mark.xfail(
+                    reason="Produces JSON but not in a consistent manner"
+                ),
+            ),
+        ],
+    )
+    def test_tuple_labels(self, orient, expected):
+        # GH 20500
+        df = DataFrame([[1]], index=[("a", "b")], columns=[("c", "d")])
+        result = df.to_json(orient=orient)
+        assert result == expected
+
+    @pytest.mark.parametrize("indent", [1, 2, 4])
+    def test_to_json_indent(self, indent):
+        # GH 12004
+        df = DataFrame([["foo", "bar"], ["baz", "qux"]], columns=["a", "b"])
+
+        result = df.to_json(indent=indent)
+        spaces = " " * indent
+        expected = f"""{{
+{spaces}"a":{{
+{spaces}{spaces}"0":"foo",
+{spaces}{spaces}"1":"baz"
+{spaces}}},
+{spaces}"b":{{
+{spaces}{spaces}"0":"bar",
+{spaces}{spaces}"1":"qux"
+{spaces}}}
+}}"""
+
+        assert result == expected
+
+    @pytest.mark.skipif(
+        using_string_dtype(),
+        reason="Adjust expected when infer_string is default, no bug here, "
+        "just a complicated parametrization",
+    )
+    @pytest.mark.parametrize(
+        "orient,expected",
+        [
+            (
+                "split",
+                """{
+    "columns":[
+        "a",
+        "b"
+    ],
+    "index":[
+        0,
+        1
+    ],
+    "data":[
+        [
+            "foo",
+            "bar"
+        ],
+        [
+            "baz",
+            "qux"
+        ]
+    ]
+}""",
+            ),
+            (
+                "records",
+                """[
+    {
+        "a":"foo",
+        "b":"bar"
+    },
+    {
+        "a":"baz",
+        "b":"qux"
+    }
+]""",
+            ),
+            (
+                "index",
+                """{
+    "0":{
+        "a":"foo",
+        "b":"bar"
+    },
+    "1":{
+        "a":"baz",
+        "b":"qux"
+    }
+}""",
+            ),
+            (
+                "columns",
+                """{
+    "a":{
+        "0":"foo",
+        "1":"baz"
+    },
+    "b":{
+        "0":"bar",
+        "1":"qux"
+    }
+}""",
+            ),
+            (
+                "values",
+                """[
+    [
+        "foo",
+        "bar"
+    ],
+    [
+        "baz",
+        "qux"
+    ]
+]""",
+            ),
+            (
+                "table",
+                """{
+    "schema":{
+        "fields":[
+            {
+                "name":"index",
+                "type":"integer"
+            },
+            {
+                "name":"a",
+                "type":"string"
+            },
+            {
+                "name":"b",
+                "type":"string"
+            }
+        ],
+        "primaryKey":[
+            "index"
+        ],
+        "pandas_version":"1.4.0"
+    },
+    "data":[
+        {
+            "index":0,
+            "a":"foo",
+            "b":"bar"
+        },
+        {
+            "index":1,
+            "a":"baz",
+            "b":"qux"
+        }
+    ]
+}""",
+            ),
+        ],
+    )
+    def test_json_indent_all_orients(self, orient, expected):
+        # GH 12004
+        df = DataFrame([["foo", "bar"], ["baz", "qux"]], columns=["a", "b"])
+        result = df.to_json(orient=orient, indent=4)
+        assert result == expected
+
+    def test_json_negative_indent_raises(self):
+        with pytest.raises(ValueError, match="must be a nonnegative integer"):
+            DataFrame().to_json(indent=-1)
+
+    def test_emca_262_nan_inf_support(self):
+        # GH 12213
+        data = StringIO(
+            '["a", NaN, "NaN", Infinity, "Infinity", -Infinity, "-Infinity"]'
+        )
+        result = read_json(data)
+        expected = DataFrame(
+            ["a", None, "NaN", np.inf, "Infinity", -np.inf, "-Infinity"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_frame_int_overflow(self):
+        # GH 30320
+        encoded_json = json.dumps([{"col": "31900441201190696999"}, {"col": "Text"}])
+        expected = DataFrame({"col": ["31900441201190696999", "Text"]})
+        result = read_json(StringIO(encoded_json))
+        tm.assert_frame_equal(result, expected)
+
+    def test_json_multiindex(self):
+        dataframe = DataFrame({"x": [1, 2, 3], "y": ["a", "b", "c"]})
+        expected = (
+            '{"(0, \'x\')":1,"(0, \'y\')":"a","(1, \'x\')":2,'
+            '"(1, \'y\')":"b","(2, \'x\')":3,"(2, \'y\')":"c"}'
+        )
+        series = dataframe.stack()
+        result = series.to_json(orient="index")
+        assert result == expected
+
+    @pytest.mark.single_cpu
+    @pytest.mark.network
+    def test_to_s3(self, s3_bucket_public, s3so):
+        # GH 28375
+        mock_bucket_name = s3_bucket_public.name
+        target_file = f"{uuid.uuid4()}.json"
+        df = DataFrame({"x": [1, 2, 3], "y": [2, 4, 6]})
+        uri = f"s3://{mock_bucket_name}/{target_file}"
+        df.to_json(uri, storage_options=s3so)
+        result = read_json(uri, storage_options=s3so)
+        tm.assert_frame_equal(result, df)
+
+    def test_json_pandas_nulls(self, nulls_fixture):
+        # GH 31615
+        expected_warning = None
+        msg = (
+            "The default 'epoch' date format is deprecated and will be removed "
+            "in a future version, please use 'iso' date format instead."
+        )
+        if nulls_fixture is pd.NaT:
+            expected_warning = Pandas4Warning
+
+        with tm.assert_produces_warning(expected_warning, match=msg):
+            result = DataFrame([[nulls_fixture]]).to_json()
+        assert result == '{"0":{"0":null}}'
+
+    def test_readjson_bool_series(self):
+        # GH31464
+        result = read_json(StringIO("[true, true, false]"), typ="series")
+        expected = Series([True, True, False])
+        tm.assert_series_equal(result, expected)
+
+    def test_to_json_multiindex_escape(self):
+        # GH 15273
+        df = DataFrame(
+            True,
+            index=date_range("2017-01-20", "2017-01-23", unit="ns"),
+            columns=["foo", "bar"],
+        ).stack()
+        result = df.to_json()
+        expected = (
+            "{\"(Timestamp('2017-01-20 00:00:00'), 'foo')\":true,"
+            "\"(Timestamp('2017-01-20 00:00:00'), 'bar')\":true,"
+            "\"(Timestamp('2017-01-21 00:00:00'), 'foo')\":true,"
+            "\"(Timestamp('2017-01-21 00:00:00'), 'bar')\":true,"
+            "\"(Timestamp('2017-01-22 00:00:00'), 'foo')\":true,"
+            "\"(Timestamp('2017-01-22 00:00:00'), 'bar')\":true,"
+            "\"(Timestamp('2017-01-23 00:00:00'), 'foo')\":true,"
+            "\"(Timestamp('2017-01-23 00:00:00'), 'bar')\":true}"
+        )
+        assert result == expected
+
+    def test_to_json_series_of_objects(self):
+        class _TestObject:
+            def __init__(self, a, b, _c, d) -> None:
+                self.a = a
+                self.b = b
+                self._c = _c
+                self.d = d
+
+            def e(self):
+                return 5
+
+        # JSON keys should be all non-callable non-underscore attributes, see GH-42768
+        series = Series([_TestObject(a=1, b=2, _c=3, d=4)])
+        assert json.loads(series.to_json()) == {"0": {"a": 1, "b": 2, "d": 4}}
+
+    @pytest.mark.parametrize(
+        "data,expected",
+        [
+            (
+                Series({0: -6 + 8j, 1: 0 + 1j, 2: 9 - 5j}),
+                '{"0":{"imag":8.0,"real":-6.0},'
+                '"1":{"imag":1.0,"real":0.0},'
+                '"2":{"imag":-5.0,"real":9.0}}',
+            ),
+            (
+                Series({0: -9.39 + 0.66j, 1: 3.95 + 9.32j, 2: 4.03 - 0.17j}),
+                '{"0":{"imag":0.66,"real":-9.39},'
+                '"1":{"imag":9.32,"real":3.95},'
+                '"2":{"imag":-0.17,"real":4.03}}',
+            ),
+            (
+                DataFrame([[-2 + 3j, -1 - 0j], [4 - 3j, -0 - 10j]]),
+                '{"0":{"0":{"imag":3.0,"real":-2.0},'
+                '"1":{"imag":-3.0,"real":4.0}},'
+                '"1":{"0":{"imag":0.0,"real":-1.0},'
+                '"1":{"imag":-10.0,"real":0.0}}}',
+            ),
+            (
+                DataFrame(
+                    [[-0.28 + 0.34j, -1.08 - 0.39j], [0.41 - 0.34j, -0.78 - 1.35j]]
+                ),
+                '{"0":{"0":{"imag":0.34,"real":-0.28},'
+                '"1":{"imag":-0.34,"real":0.41}},'
+                '"1":{"0":{"imag":-0.39,"real":-1.08},'
+                '"1":{"imag":-1.35,"real":-0.78}}}',
+            ),
+        ],
+    )
+    def test_complex_data_tojson(self, data, expected):
+        # GH41174
+        result = data.to_json()
+        assert result == expected
+
+    def test_json_uint64(self):
+        # GH21073
+        expected = (
+            '{"columns":["col1"],"index":[0,1],'
+            '"data":[[13342205958987758245],[12388075603347835679]]}'
+        )
+        df = DataFrame(data={"col1": [13342205958987758245, 12388075603347835679]})
+        result = df.to_json(orient="split")
+        assert result == expected
+
+    def test_read_json_dtype_backend(
+        self, string_storage, dtype_backend, orient, using_infer_string
+    ):
+        # GH#50750
+        df = DataFrame(
+            {
+                "a": Series([1, NA, 3], dtype="Int64"),
+                "b": Series([1, 2, 3], dtype="Int64"),
+                "c": Series([1.5, NA, 2.5], dtype="Float64"),
+                "d": Series([1.5, 2.0, 2.5], dtype="Float64"),
+                "e": [True, False, None],
+                "f": [True, False, True],
+                "g": ["a", "b", "c"],
+                "h": ["a", "b", None],
+            }
+        )
+
+        out = df.to_json(orient=orient)
+        with pd.option_context("mode.string_storage", string_storage):
+            result = read_json(
+                StringIO(out), dtype_backend=dtype_backend, orient=orient
+            )
+
+        if dtype_backend == "pyarrow":
+            pa = pytest.importorskip("pyarrow")
+            string_dtype = pd.ArrowDtype(pa.string())
+        else:
+            string_dtype = pd.StringDtype(string_storage)
+
+        expected = DataFrame(
+            {
+                "a": Series([1, NA, 3], dtype="Int64"),
+                "b": Series([1, 2, 3], dtype="Int64"),
+                "c": Series([1.5, NA, 2.5], dtype="Float64"),
+                "d": Series([1.5, 2.0, 2.5], dtype="Float64"),
+                "e": Series([True, False, NA], dtype="boolean"),
+                "f": Series([True, False, True], dtype="boolean"),
+                "g": Series(["a", "b", "c"], dtype=string_dtype),
+                "h": Series(["a", "b", None], dtype=string_dtype),
+            }
+        )
+
+        if dtype_backend == "pyarrow":
+            pa = pytest.importorskip("pyarrow")
+            from pandas.arrays import ArrowExtensionArray
+
+            expected = DataFrame(
+                {
+                    col: ArrowExtensionArray(pa.array(expected[col], from_pandas=True))
+                    for col in expected.columns
+                }
+            )
+
+        if orient == "values":
+            expected.columns = list(range(8))
+
+        # the storage of the str columns' Index is also affected by the
+        # string_storage setting -> ignore that for checking the result
+        tm.assert_frame_equal(result, expected, check_column_type=False)
+
+    @td.skip_if_no("pyarrow")
+    @pytest.mark.filterwarnings("ignore:Passing a BlockManager:DeprecationWarning")
+    def test_read_json_pyarrow_with_dtype(self):
+        dtype = {"a": "int32[pyarrow]", "b": "int64[pyarrow]"}
+        json = b'{"a": 1, "b": 2}\n'
+
+        df = read_json(
+            BytesIO(json),
+            dtype=dtype,
+            lines=True,
+            engine="pyarrow",
+            dtype_backend="pyarrow",
+        )
+
+        result = df.dtypes
+        expected = Series(
+            data=[
+                pd.ArrowDtype.construct_from_string("int32[pyarrow]"),
+                pd.ArrowDtype.construct_from_string("int64[pyarrow]"),
+            ],
+            index=["a", "b"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("orient", ["split", "records", "index"])
+    def test_read_json_nullable_series(self, string_storage, dtype_backend, orient):
+        # GH#50750
+        pa = pytest.importorskip("pyarrow")
+        ser = Series([1, NA, 3], dtype="Int64")
+
+        out = ser.to_json(orient=orient)
+        with pd.option_context("mode.string_storage", string_storage):
+            result = read_json(
+                StringIO(out), dtype_backend=dtype_backend, orient=orient, typ="series"
+            )
+
+        expected = Series([1, NA, 3], dtype="Int64")
+
+        if dtype_backend == "pyarrow":
+            from pandas.arrays import ArrowExtensionArray
+
+            expected = Series(ArrowExtensionArray(pa.array(expected, from_pandas=True)))
+
+        tm.assert_series_equal(result, expected)
+
+    def test_invalid_dtype_backend(self):
+        msg = (
+            "dtype_backend numpy is invalid, only 'numpy_nullable' and "
+            "'pyarrow' are allowed."
+        )
+        with pytest.raises(ValueError, match=msg):
+            read_json("test", dtype_backend="numpy")
+
+
+def test_invalid_engine():
+    # GH 48893
+    ser = Series(range(1))
+    out = ser.to_json()
+    with pytest.raises(ValueError, match="The engine type foo"):
+        read_json(out, engine="foo")
+
+
+def test_pyarrow_engine_lines_false():
+    # GH 48893
+    ser = Series(range(1))
+    out = ser.to_json()
+    with pytest.raises(ValueError, match="currently pyarrow engine only supports"):
+        read_json(out, engine="pyarrow", lines=False)
+
+
+def test_json_roundtrip_string_inference(orient):
+    df = DataFrame(
+        [["a", "b"], ["c", "d"]], index=["row 1", "row 2"], columns=["col 1", "col 2"]
+    )
+    out = df.to_json()
+    with pd.option_context("future.infer_string", True):
+        result = read_json(StringIO(out))
+    dtype = pd.StringDtype(na_value=np.nan)
+    expected = DataFrame(
+        [["a", "b"], ["c", "d"]],
+        dtype=dtype,
+        index=Index(["row 1", "row 2"], dtype=dtype),
+        columns=Index(["col 1", "col 2"], dtype=dtype),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("pyarrow")
+def test_to_json_ea_null():
+    # GH#57224
+    df = DataFrame(
+        {
+            "a": Series([1, NA], dtype="int64[pyarrow]"),
+            "b": Series([2, NA], dtype="Int64"),
+        }
+    )
+    result = df.to_json(orient="records", lines=True)
+    expected = """{"a":1,"b":2}
+{"a":null,"b":null}
+"""
+    assert result == expected
+
+
+def test_read_json_lines_rangeindex():
+    # GH 57429
+    data = """
+{"a": 1, "b": 2}
+{"a": 3, "b": 4}
+"""
+    result = read_json(StringIO(data), lines=True).index
+    expected = RangeIndex(2)
+    tm.assert_index_equal(result, expected, exact=True)
+
+
+def test_large_number():
+    # GH#20608
+    result = read_json(
+        StringIO('["9999999999999999"]'),
+        orient="values",
+        typ="series",
+        convert_dates=False,
+    )
+    expected = Series([9999999999999999])
+    tm.assert_series_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/json/test_readlines.py

@@ -0,0 +1,544 @@
+from collections.abc import Iterator
+from io import (
+    BytesIO,
+    StringIO,
+)
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    read_json,
+)
+import pandas._testing as tm
+
+from pandas.io.json._json import JsonReader
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+@pytest.fixture
+def lines_json_df():
+    df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    return df.to_json(lines=True, orient="records")
+
+
+@pytest.fixture(params=["ujson", "pyarrow"])
+def engine(request):
+    if request.param == "pyarrow":
+        pytest.importorskip("pyarrow.json")
+    return request.param
+
+
+def test_read_jsonl():
+    # GH9180
+    result = read_json(StringIO('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n'), lines=True)
+    expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_jsonl_engine_pyarrow(datapath, engine):
+    result = read_json(
+        datapath("io", "json", "data", "line_delimited.json"),
+        lines=True,
+        engine=engine,
+    )
+    expected = DataFrame({"a": [1, 3, 5], "b": [2, 4, 6]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_datetime(request, engine):
+    # GH33787
+    if engine == "pyarrow":
+        # GH 48893
+        reason = "Pyarrow only supports a file path as an input and line delimited json"
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    df = DataFrame(
+        [([1, 2], ["2020-03-05", "2020-04-08T09:58:49+00:00"], "hector")],
+        columns=["accounts", "date", "name"],
+    )
+    json_line = df.to_json(lines=True, orient="records")
+
+    if engine == "pyarrow":
+        result = read_json(StringIO(json_line), engine=engine)
+    else:
+        result = read_json(StringIO(json_line), engine=engine)
+    expected = DataFrame(
+        [[1, "2020-03-05", "hector"], [2, "2020-04-08T09:58:49+00:00", "hector"]],
+        columns=["accounts", "date", "name"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_jsonl_unicode_chars():
+    # GH15132: non-ascii unicode characters
+    # \u201d == RIGHT DOUBLE QUOTATION MARK
+
+    # simulate file handle
+    json = '{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n'
+    json = StringIO(json)
+    result = read_json(json, lines=True)
+    expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
+    tm.assert_frame_equal(result, expected)
+
+    # simulate string
+    json = '{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n'
+    result = read_json(StringIO(json), lines=True)
+    expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_to_jsonl():
+    # GH9180
+    df = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+    result = df.to_json(orient="records", lines=True)
+    expected = '{"a":1,"b":2}\n{"a":1,"b":2}\n'
+    assert result == expected
+
+    df = DataFrame([["foo}", "bar"], ['foo"', "bar"]], columns=["a", "b"])
+    result = df.to_json(orient="records", lines=True)
+    expected = '{"a":"foo}","b":"bar"}\n{"a":"foo\\"","b":"bar"}\n'
+    assert result == expected
+    tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
+
+    # GH15096: escaped characters in columns and data
+    df = DataFrame([["foo\\", "bar"], ['foo"', "bar"]], columns=["a\\", "b"])
+    result = df.to_json(orient="records", lines=True)
+    expected = '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}\n'
+    assert result == expected
+    tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
+
+
+def test_to_jsonl_count_new_lines():
+    # GH36888
+    df = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+    actual_new_lines_count = df.to_json(orient="records", lines=True).count("\n")
+    expected_new_lines_count = 2
+    assert actual_new_lines_count == expected_new_lines_count
+
+
+@pytest.mark.parametrize("chunksize", [1, 1.0])
+@pytest.mark.parametrize("buffer", [BytesIO, StringIO])
+def test_readjson_chunks(request, lines_json_df, chunksize, buffer, engine):
+    # Basic test that read_json(chunks=True) gives the same result as
+    # read_json(chunks=False)
+    # GH17048: memory usage when lines=True
+    # GH#28906: read binary json lines in chunks
+
+    if buffer == BytesIO:
+        lines_json_df = lines_json_df.encode()
+
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    unchunked = read_json(buffer(lines_json_df), lines=True)
+    with (
+        buffer(lines_json_df) as buf,
+        read_json(buf, lines=True, chunksize=chunksize, engine=engine) as reader,
+    ):
+        chunked = pd.concat(reader)
+
+    tm.assert_frame_equal(chunked, unchunked)
+
+
+def test_readjson_chunksize_requires_lines(lines_json_df, engine):
+    msg = "chunksize can only be passed if lines=True"
+    with pytest.raises(ValueError, match=msg):
+        with read_json(
+            StringIO(lines_json_df), lines=False, chunksize=2, engine=engine
+        ) as _:
+            pass
+
+
+def test_readjson_chunks_series(request, engine):
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason))
+
+    # Test reading line-format JSON to Series with chunksize param
+    s = pd.Series({"A": 1, "B": 2})
+
+    strio = StringIO(s.to_json(lines=True, orient="records"))
+    unchunked = read_json(strio, lines=True, typ="series", engine=engine)
+
+    strio = StringIO(s.to_json(lines=True, orient="records"))
+    with read_json(
+        strio, lines=True, typ="series", chunksize=1, engine=engine
+    ) as reader:
+        chunked = pd.concat(reader)
+
+    tm.assert_series_equal(chunked, unchunked)
+
+
+def test_readjson_each_chunk(request, lines_json_df, engine):
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    # Other tests check that the final result of read_json(chunksize=True)
+    # is correct. This checks the intermediate chunks.
+    with read_json(
+        StringIO(lines_json_df), lines=True, chunksize=2, engine=engine
+    ) as reader:
+        chunks = list(reader)
+    assert chunks[0].shape == (2, 2)
+    assert chunks[1].shape == (1, 2)
+
+
+def test_readjson_chunks_from_file(request, engine, temp_file):
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    df.to_json(temp_file, lines=True, orient="records")
+    with read_json(temp_file, lines=True, chunksize=1, engine=engine) as reader:
+        chunked = pd.concat(reader)
+    unchunked = read_json(temp_file, lines=True, engine=engine)
+    tm.assert_frame_equal(unchunked, chunked)
+
+
+@pytest.mark.parametrize("chunksize", [None, 1])
+def test_readjson_chunks_closes(chunksize, temp_file):
+    df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    df.to_json(temp_file, lines=True, orient="records")
+    reader = JsonReader(
+        temp_file,
+        orient=None,
+        typ="frame",
+        dtype=True,
+        convert_axes=True,
+        convert_dates=True,
+        keep_default_dates=True,
+        precise_float=False,
+        date_unit=None,
+        encoding=None,
+        lines=True,
+        chunksize=chunksize,
+        compression=None,
+        nrows=None,
+    )
+    with reader:
+        reader.read()
+    assert reader.handles.handle.closed, (
+        f"didn't close stream with chunksize = {chunksize}"
+    )
+
+
+@pytest.mark.parametrize("chunksize", [0, -1, 2.2, "foo"])
+def test_readjson_invalid_chunksize(lines_json_df, chunksize, engine):
+    msg = r"'chunksize' must be an integer >=1"
+
+    with pytest.raises(ValueError, match=msg):
+        with read_json(
+            StringIO(lines_json_df), lines=True, chunksize=chunksize, engine=engine
+        ) as _:
+            pass
+
+
+@pytest.mark.parametrize("chunksize", [None, 1, 2])
+def test_readjson_chunks_multiple_empty_lines(chunksize):
+    j = """
+
+    {"A":1,"B":4}
+
+
+
+    {"A":2,"B":5}
+
+
+
+
+
+
+
+    {"A":3,"B":6}
+    """
+    orig = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    test = read_json(StringIO(j), lines=True, chunksize=chunksize)
+    if chunksize is not None:
+        with test:
+            test = pd.concat(test)
+    tm.assert_frame_equal(orig, test, obj=f"chunksize: {chunksize}")
+
+
+def test_readjson_unicode(request, monkeypatch, engine, temp_file):
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    monkeypatch.setattr("locale.getpreferredencoding", lambda do_setlocale: "cp949")
+    with open(temp_file, "w", encoding="utf-8") as f:
+        f.write('{"£©µÀÆÖÞßéöÿ":["АБВГДабвгд가"]}')
+
+    result = read_json(temp_file, engine=engine)
+    expected = DataFrame({"£©µÀÆÖÞßéöÿ": ["АБВГДабвгд가"]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("nrows", [1, 2])
+def test_readjson_nrows(nrows, engine):
+    # GH 33916
+    # Test reading line-format JSON to Series with nrows param
+    jsonl = """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}"""
+    result = read_json(StringIO(jsonl), lines=True, nrows=nrows)
+    expected = DataFrame({"a": [1, 3, 5, 7], "b": [2, 4, 6, 8]}).iloc[:nrows]
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("nrows,chunksize", [(2, 2), (4, 2)])
+def test_readjson_nrows_chunks(request, nrows, chunksize, engine):
+    # GH 33916
+    # Test reading line-format JSON to Series with nrows and chunksize param
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    jsonl = """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}"""
+
+    if engine != "pyarrow":
+        with read_json(
+            StringIO(jsonl), lines=True, nrows=nrows, chunksize=chunksize, engine=engine
+        ) as reader:
+            chunked = pd.concat(reader)
+    else:
+        with read_json(
+            jsonl, lines=True, nrows=nrows, chunksize=chunksize, engine=engine
+        ) as reader:
+            chunked = pd.concat(reader)
+    expected = DataFrame({"a": [1, 3, 5, 7], "b": [2, 4, 6, 8]}).iloc[:nrows]
+    tm.assert_frame_equal(chunked, expected)
+
+
+def test_readjson_nrows_requires_lines(engine):
+    # GH 33916
+    # Test ValueError raised if nrows is set without setting lines in read_json
+    jsonl = """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}"""
+    msg = "nrows can only be passed if lines=True"
+    with pytest.raises(ValueError, match=msg):
+        read_json(jsonl, lines=False, nrows=2, engine=engine)
+
+
+def test_readjson_lines_chunks_fileurl(request, datapath, engine):
+    # GH 27135
+    # Test reading line-format JSON from file url
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    df_list_expected = [
+        DataFrame([[1, 2]], columns=["a", "b"], index=[0]),
+        DataFrame([[3, 4]], columns=["a", "b"], index=[1]),
+        DataFrame([[5, 6]], columns=["a", "b"], index=[2]),
+    ]
+    os_path = datapath("io", "json", "data", "line_delimited.json")
+    file_url = Path(os_path).as_uri()
+    with read_json(file_url, lines=True, chunksize=1, engine=engine) as url_reader:
+        for index, chuck in enumerate(url_reader):
+            tm.assert_frame_equal(chuck, df_list_expected[index])
+
+
+def test_chunksize_is_incremental():
+    # See https://github.com/pandas-dev/pandas/issues/34548
+    jsonl = (
+        """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}\n"""
+        * 1000
+    )
+
+    class MyReader:
+        def __init__(self, contents) -> None:
+            self.read_count = 0
+            self.stringio = StringIO(contents)
+
+        def read(self, *args):
+            self.read_count += 1
+            return self.stringio.read(*args)
+
+        def __iter__(self) -> Iterator:
+            self.read_count += 1
+            return iter(self.stringio)
+
+    reader = MyReader(jsonl)
+    assert len(list(read_json(reader, lines=True, chunksize=100))) > 1
+    assert reader.read_count > 10
+
+
+@pytest.mark.parametrize("orient_", ["split", "index", "table"])
+def test_to_json_append_orient(orient_):
+    # GH 35849
+    # Test ValueError when orient is not 'records'
+    df = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    msg = (
+        r"mode='a' \(append\) is only supported when "
+        "lines is True and orient is 'records'"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.to_json(mode="a", orient=orient_)
+
+
+def test_to_json_append_lines():
+    # GH 35849
+    # Test ValueError when lines is not True
+    df = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    msg = (
+        r"mode='a' \(append\) is only supported when "
+        "lines is True and orient is 'records'"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.to_json(mode="a", lines=False, orient="records")
+
+
+@pytest.mark.parametrize("mode_", ["r", "x"])
+def test_to_json_append_mode(mode_):
+    # GH 35849
+    # Test ValueError when mode is not supported option
+    df = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    msg = (
+        f"mode={mode_} is not a valid option.Only 'w' and 'a' are currently supported."
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.to_json(mode=mode_, lines=False, orient="records")
+
+
+def test_to_json_append_output_consistent_columns(temp_file):
+    # GH 35849
+    # Testing that resulting output reads in as expected.
+    # Testing same columns, new rows
+    df1 = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    df2 = DataFrame({"col1": [3, 4], "col2": ["c", "d"]})
+
+    expected = DataFrame({"col1": [1, 2, 3, 4], "col2": ["a", "b", "c", "d"]})
+    # Save dataframes to the same file
+    df1.to_json(temp_file, lines=True, orient="records")
+    df2.to_json(temp_file, mode="a", lines=True, orient="records")
+
+    # Read path file
+    result = read_json(temp_file, lines=True)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_to_json_append_output_inconsistent_columns(temp_file):
+    # GH 35849
+    # Testing that resulting output reads in as expected.
+    # Testing one new column, one old column, new rows
+    df1 = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    df3 = DataFrame({"col2": ["e", "f"], "col3": ["!", "#"]})
+
+    expected = DataFrame(
+        {
+            "col1": [1, 2, None, None],
+            "col2": ["a", "b", "e", "f"],
+            "col3": [np.nan, np.nan, "!", "#"],
+        }
+    )
+    # Save dataframes to the same file
+    df1.to_json(temp_file, mode="a", lines=True, orient="records")
+    df3.to_json(temp_file, mode="a", lines=True, orient="records")
+
+    # Read path file
+    result = read_json(temp_file, lines=True)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_to_json_append_output_different_columns(temp_file):
+    # GH 35849
+    # Testing that resulting output reads in as expected.
+    # Testing same, differing and new columns
+    df1 = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    df2 = DataFrame({"col1": [3, 4], "col2": ["c", "d"]})
+    df3 = DataFrame({"col2": ["e", "f"], "col3": ["!", "#"]})
+    df4 = DataFrame({"col4": [True, False]})
+
+    expected = DataFrame(
+        {
+            "col1": [1, 2, 3, 4, None, None, None, None],
+            "col2": ["a", "b", "c", "d", "e", "f", np.nan, np.nan],
+            "col3": [np.nan, np.nan, np.nan, np.nan, "!", "#", np.nan, np.nan],
+            "col4": [None, None, None, None, None, None, True, False],
+        }
+    ).astype({"col4": "float"})
+    # Save dataframes to the same file
+    df1.to_json(temp_file, mode="a", lines=True, orient="records")
+    df2.to_json(temp_file, mode="a", lines=True, orient="records")
+    df3.to_json(temp_file, mode="a", lines=True, orient="records")
+    df4.to_json(temp_file, mode="a", lines=True, orient="records")
+
+    # Read path file
+    result = read_json(temp_file, lines=True)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_to_json_append_output_different_columns_reordered(temp_file):
+    # GH 35849
+    # Testing that resulting output reads in as expected.
+    # Testing specific result column order.
+    df1 = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    df2 = DataFrame({"col1": [3, 4], "col2": ["c", "d"]})
+    df3 = DataFrame({"col2": ["e", "f"], "col3": ["!", "#"]})
+    df4 = DataFrame({"col4": [True, False]})
+
+    # df4, df3, df2, df1 (in that order)
+    expected = DataFrame(
+        {
+            "col4": [True, False, None, None, None, None, None, None],
+            "col2": [np.nan, np.nan, "e", "f", "c", "d", "a", "b"],
+            "col3": [np.nan, np.nan, "!", "#", np.nan, np.nan, np.nan, np.nan],
+            "col1": [None, None, None, None, 3, 4, 1, 2],
+        }
+    ).astype({"col4": "float"})
+    # Save dataframes to the same file
+    df4.to_json(temp_file, mode="a", lines=True, orient="records")
+    df3.to_json(temp_file, mode="a", lines=True, orient="records")
+    df2.to_json(temp_file, mode="a", lines=True, orient="records")
+    df1.to_json(temp_file, mode="a", lines=True, orient="records")
+
+    # Read path file
+    result = read_json(temp_file, lines=True)
+    tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/json/test_ujson.py

@@ -0,0 +1,1045 @@
+import calendar
+import datetime
+import decimal
+import json
+import locale
+import math
+import re
+import time
+
+import dateutil
+import numpy as np
+import pytest
+
+import pandas._libs.json as ujson
+from pandas.compat import IS64
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    NaT,
+    PeriodIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+def _clean_dict(d):
+    """
+    Sanitize dictionary for JSON by converting all keys to strings.
+
+    Parameters
+    ----------
+    d : dict
+        The dictionary to convert.
+
+    Returns
+    -------
+    cleaned_dict : dict
+    """
+    return {str(k): v for k, v in d.items()}
+
+
+@pytest.fixture(
+    params=[None, "split", "records", "values", "index"]  # Column indexed by default.
+)
+def orient(request):
+    return request.param
+
+
+class TestUltraJSONTests:
+    @pytest.mark.skipif(not IS64, reason="not compliant on 32-bit, xref #15865")
+    @pytest.mark.parametrize(
+        "value, double_precision",
+        [
+            ("1337.1337", 15),
+            ("0.95", 1),
+            ("0.94", 1),
+            ("1.95", 1),
+            ("-1.95", 1),
+            ("0.995", 2),
+            ("0.9995", 3),
+            ("0.99999999999999944", 15),
+        ],
+    )
+    def test_encode_decimal(self, value, double_precision):
+        sut = decimal.Decimal(value)
+        encoded = ujson.ujson_dumps(sut, double_precision=double_precision)
+        decoded = ujson.ujson_loads(encoded)
+        assert decoded == value
+
+    @pytest.mark.parametrize("ensure_ascii", [True, False])
+    def test_encode_string_conversion(self, ensure_ascii):
+        string_input = "A string \\ / \b \f \n \r \t </script> &"
+        not_html_encoded = '"A string \\\\ \\/ \\b \\f \\n \\r \\t <\\/script> &"'
+        html_encoded = (
+            '"A string \\\\ \\/ \\b \\f \\n \\r \\t \\u003c\\/script\\u003e \\u0026"'
+        )
+
+        def helper(expected_output, **encode_kwargs):
+            output = ujson.ujson_dumps(
+                string_input, ensure_ascii=ensure_ascii, **encode_kwargs
+            )
+
+            assert output == expected_output
+            assert string_input == json.loads(output)
+            assert string_input == ujson.ujson_loads(output)
+
+        # Default behavior assumes encode_html_chars=False.
+        helper(not_html_encoded)
+
+        # Make sure explicit encode_html_chars=False works.
+        helper(not_html_encoded, encode_html_chars=False)
+
+        # Make sure explicit encode_html_chars=True does the encoding.
+        helper(html_encoded, encode_html_chars=True)
+
+    @pytest.mark.parametrize(
+        "long_number", [-4342969734183514, -12345678901234.56789012, -528656961.4399388]
+    )
+    def test_double_long_numbers(self, long_number):
+        sut = {"a": long_number}
+        encoded = ujson.ujson_dumps(sut, double_precision=15)
+
+        decoded = ujson.ujson_loads(encoded)
+        assert sut == decoded
+
+    def test_encode_non_c_locale(self):
+        lc_category = locale.LC_NUMERIC
+
+        # We just need one of these locales to work.
+        for new_locale in ("it_IT.UTF-8", "Italian_Italy"):
+            if tm.can_set_locale(new_locale, lc_category):
+                with tm.set_locale(new_locale, lc_category):
+                    assert ujson.ujson_loads(ujson.ujson_dumps(4.78e60)) == 4.78e60
+                    assert ujson.ujson_loads("4.78", precise_float=True) == 4.78
+                break
+
+    def test_decimal_decode_test_precise(self):
+        sut = {"a": 4.56}
+        encoded = ujson.ujson_dumps(sut)
+        decoded = ujson.ujson_loads(encoded, precise_float=True)
+        assert sut == decoded
+
+    def test_encode_double_tiny_exponential(self):
+        num = 1e-40
+        assert num == ujson.ujson_loads(ujson.ujson_dumps(num))
+        num = 1e-100
+        assert num == ujson.ujson_loads(ujson.ujson_dumps(num))
+        num = -1e-45
+        assert num == ujson.ujson_loads(ujson.ujson_dumps(num))
+        num = -1e-145
+        assert np.allclose(num, ujson.ujson_loads(ujson.ujson_dumps(num)))
+
+    @pytest.mark.parametrize("unicode_key", ["key1", "بن"])
+    def test_encode_dict_with_unicode_keys(self, unicode_key):
+        unicode_dict = {unicode_key: "value1"}
+        assert unicode_dict == ujson.ujson_loads(ujson.ujson_dumps(unicode_dict))
+
+    @pytest.mark.parametrize("double_input", [math.pi, -math.pi])
+    def test_encode_double_conversion(self, double_input):
+        output = ujson.ujson_dumps(double_input)
+        assert round(double_input, 5) == round(json.loads(output), 5)
+        assert round(double_input, 5) == round(ujson.ujson_loads(output), 5)
+
+    def test_encode_with_decimal(self):
+        decimal_input = 1.0
+        output = ujson.ujson_dumps(decimal_input)
+
+        assert output == "1.0"
+
+    def test_encode_array_of_nested_arrays(self):
+        nested_input = [[[[]]]] * 20
+        output = ujson.ujson_dumps(nested_input)
+
+        assert nested_input == json.loads(output)
+        assert nested_input == ujson.ujson_loads(output)
+
+    def test_encode_array_of_doubles(self):
+        doubles_input = [31337.31337, 31337.31337, 31337.31337, 31337.31337] * 10
+        output = ujson.ujson_dumps(doubles_input)
+
+        assert doubles_input == json.loads(output)
+        assert doubles_input == ujson.ujson_loads(output)
+
+    def test_double_precision(self):
+        double_input = 30.012345678901234
+        output = ujson.ujson_dumps(double_input, double_precision=15)
+
+        assert double_input == json.loads(output)
+        assert double_input == ujson.ujson_loads(output)
+
+        for double_precision in (3, 9):
+            output = ujson.ujson_dumps(double_input, double_precision=double_precision)
+            rounded_input = round(double_input, double_precision)
+
+            assert rounded_input == json.loads(output)
+            assert rounded_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize(
+        "invalid_val",
+        [
+            20,
+            -1,
+            "9",
+            None,
+        ],
+    )
+    def test_invalid_double_precision(self, invalid_val):
+        double_input = 30.12345678901234567890
+        expected_exception = ValueError if isinstance(invalid_val, int) else TypeError
+        msg = (
+            r"Invalid value '.*' for option 'double_precision', max is '15'|"
+            r"an integer is required \(got type |"
+            r"object cannot be interpreted as an integer"
+        )
+        with pytest.raises(expected_exception, match=msg):
+            ujson.ujson_dumps(double_input, double_precision=invalid_val)
+
+    def test_encode_string_conversion2(self):
+        string_input = "A string \\ / \b \f \n \r \t"
+        output = ujson.ujson_dumps(string_input)
+
+        assert string_input == json.loads(output)
+        assert string_input == ujson.ujson_loads(output)
+        assert output == '"A string \\\\ \\/ \\b \\f \\n \\r \\t"'
+
+    @pytest.mark.parametrize(
+        "unicode_input",
+        ["Räksmörgås اسامة بن محمد بن عوض بن لادن", "\xe6\x97\xa5\xd1\x88"],
+    )
+    def test_encode_unicode_conversion(self, unicode_input):
+        enc = ujson.ujson_dumps(unicode_input)
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(unicode_input)
+        assert dec == json.loads(enc)
+
+    def test_encode_control_escaping(self):
+        escaped_input = "\x19"
+        enc = ujson.ujson_dumps(escaped_input)
+        dec = ujson.ujson_loads(enc)
+
+        assert escaped_input == dec
+        assert enc == json.dumps(escaped_input)
+
+    def test_encode_unicode_surrogate_pair(self):
+        surrogate_input = "\xf0\x90\x8d\x86"
+        enc = ujson.ujson_dumps(surrogate_input)
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(surrogate_input)
+        assert dec == json.loads(enc)
+
+    def test_encode_unicode_4bytes_utf8(self):
+        four_bytes_input = "\xf0\x91\x80\xb0TRAILINGNORMAL"
+        enc = ujson.ujson_dumps(four_bytes_input)
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(four_bytes_input)
+        assert dec == json.loads(enc)
+
+    def test_encode_unicode_4bytes_utf8highest(self):
+        four_bytes_input = "\xf3\xbf\xbf\xbfTRAILINGNORMAL"
+        enc = ujson.ujson_dumps(four_bytes_input)
+
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(four_bytes_input)
+        assert dec == json.loads(enc)
+
+    def test_encode_unicode_error(self):
+        string = "'\udac0'"
+        msg = (
+            r"'utf-8' codec can't encode character '\\udac0' "
+            r"in position 1: surrogates not allowed"
+        )
+        with pytest.raises(UnicodeEncodeError, match=msg):
+            ujson.ujson_dumps([string])
+
+    def test_encode_array_in_array(self):
+        arr_in_arr_input = [[[[]]]]
+        output = ujson.ujson_dumps(arr_in_arr_input)
+
+        assert arr_in_arr_input == json.loads(output)
+        assert output == json.dumps(arr_in_arr_input)
+        assert arr_in_arr_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize(
+        "num_input",
+        [
+            31337,
+            -31337,  # Negative number.
+            -9223372036854775808,  # Large negative number.
+        ],
+    )
+    def test_encode_num_conversion(self, num_input):
+        output = ujson.ujson_dumps(num_input)
+        assert num_input == json.loads(output)
+        assert output == json.dumps(num_input)
+        assert num_input == ujson.ujson_loads(output)
+
+    def test_encode_list_conversion(self):
+        list_input = [1, 2, 3, 4]
+        output = ujson.ujson_dumps(list_input)
+
+        assert list_input == json.loads(output)
+        assert list_input == ujson.ujson_loads(output)
+
+    def test_encode_dict_conversion(self):
+        dict_input = {"k1": 1, "k2": 2, "k3": 3, "k4": 4}
+        output = ujson.ujson_dumps(dict_input)
+
+        assert dict_input == json.loads(output)
+        assert dict_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize("builtin_value", [None, True, False])
+    def test_encode_builtin_values_conversion(self, builtin_value):
+        output = ujson.ujson_dumps(builtin_value)
+        assert builtin_value == json.loads(output)
+        assert output == json.dumps(builtin_value)
+        assert builtin_value == ujson.ujson_loads(output)
+
+    def test_encode_datetime_conversion(self):
+        datetime_input = datetime.datetime.fromtimestamp(time.time())
+        output = ujson.ujson_dumps(datetime_input, date_unit="s")
+        expected = calendar.timegm(datetime_input.utctimetuple())
+
+        assert int(expected) == json.loads(output)
+        assert int(expected) == ujson.ujson_loads(output)
+
+    def test_encode_date_conversion(self):
+        date_input = datetime.date.fromtimestamp(time.time())
+        output = ujson.ujson_dumps(date_input, date_unit="s")
+
+        tup = (date_input.year, date_input.month, date_input.day, 0, 0, 0)
+        expected = calendar.timegm(tup)
+
+        assert int(expected) == json.loads(output)
+        assert int(expected) == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize(
+        "test",
+        [datetime.time(), datetime.time(1, 2, 3), datetime.time(10, 12, 15, 343243)],
+    )
+    def test_encode_time_conversion_basic(self, test):
+        output = ujson.ujson_dumps(test)
+        expected = f'"{test.isoformat()}"'
+        assert expected == output
+
+    def test_encode_time_conversion_pytz(self):
+        # see gh-11473: to_json segfaults with timezone-aware datetimes
+        pytz = pytest.importorskip("pytz")
+        test = datetime.time(10, 12, 15, 343243, pytz.utc)
+        output = ujson.ujson_dumps(test)
+        expected = f'"{test.isoformat()}"'
+        assert expected == output
+
+    def test_encode_time_conversion_dateutil(self):
+        # see gh-11473: to_json segfaults with timezone-aware datetimes
+        test = datetime.time(10, 12, 15, 343243, dateutil.tz.tzutc())
+        output = ujson.ujson_dumps(test)
+        expected = f'"{test.isoformat()}"'
+        assert expected == output
+
+    @pytest.mark.parametrize(
+        "decoded_input", [NaT, np.datetime64("NaT", "ns"), np.nan, np.inf, -np.inf]
+    )
+    def test_encode_as_null(self, decoded_input):
+        assert ujson.ujson_dumps(decoded_input) == "null", "Expected null"
+
+    def test_datetime_units(self):
+        val = datetime.datetime(2013, 8, 17, 21, 17, 12, 215504)
+        stamp = Timestamp(val).as_unit("ns")
+
+        roundtrip = ujson.ujson_loads(ujson.ujson_dumps(val, date_unit="s"))
+        assert roundtrip == stamp._value // 10**9
+
+        roundtrip = ujson.ujson_loads(ujson.ujson_dumps(val, date_unit="ms"))
+        assert roundtrip == stamp._value // 10**6
+
+        roundtrip = ujson.ujson_loads(ujson.ujson_dumps(val, date_unit="us"))
+        assert roundtrip == stamp._value // 10**3
+
+        roundtrip = ujson.ujson_loads(ujson.ujson_dumps(val, date_unit="ns"))
+        assert roundtrip == stamp._value
+
+        msg = "Invalid value 'foo' for option 'date_unit'"
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_dumps(val, date_unit="foo")
+
+    def test_encode_to_utf8(self):
+        unencoded = "\xe6\x97\xa5\xd1\x88"
+
+        enc = ujson.ujson_dumps(unencoded, ensure_ascii=False)
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(unencoded, ensure_ascii=False)
+        assert dec == json.loads(enc)
+
+    def test_decode_from_unicode(self):
+        unicode_input = '{"obj": 31337}'
+
+        dec1 = ujson.ujson_loads(unicode_input)
+        dec2 = ujson.ujson_loads(str(unicode_input))
+
+        assert dec1 == dec2
+
+    def test_encode_recursion_max(self):
+        # 8 is the max recursion depth
+
+        class O2:
+            member = 0
+
+        class O1:
+            member = 0
+
+        decoded_input = O1()
+        decoded_input.member = O2()
+        decoded_input.member.member = decoded_input
+
+        with pytest.raises(OverflowError, match="Maximum recursion level reached"):
+            ujson.ujson_dumps(decoded_input)
+
+    def test_decode_jibberish(self):
+        jibberish = "fdsa sda v9sa fdsa"
+        msg = "Unexpected character found when decoding 'false'"
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(jibberish)
+
+    @pytest.mark.parametrize(
+        "broken_json",
+        [
+            "[",  # Broken array start.
+            "{",  # Broken object start.
+            "]",  # Broken array end.
+            "}",  # Broken object end.
+        ],
+    )
+    def test_decode_broken_json(self, broken_json):
+        msg = "Expected object or value"
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(broken_json)
+
+    @pytest.mark.parametrize("too_big_char", ["[", "{"])
+    def test_decode_depth_too_big(self, too_big_char):
+        with pytest.raises(ValueError, match="Reached object decoding depth limit"):
+            ujson.ujson_loads(too_big_char * (1024 * 1024))
+
+    @pytest.mark.parametrize(
+        "bad_string",
+        [
+            '"TESTING',  # Unterminated.
+            '"TESTING\\"',  # Unterminated escape.
+            "tru",  # Broken True.
+            "fa",  # Broken False.
+            "n",  # Broken None.
+        ],
+    )
+    def test_decode_bad_string(self, bad_string):
+        msg = (
+            "Unexpected character found when decoding|"
+            "Unmatched ''\"' when when decoding 'string'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(bad_string)
+
+    @pytest.mark.parametrize(
+        "broken_json, err_msg",
+        [
+            (
+                '{{1337:""}}',
+                "Key name of object must be 'string' when decoding 'object'",
+            ),
+            ('{{"key":"}', "Unmatched ''\"' when when decoding 'string'"),
+            ("[[[true", "Unexpected character found when decoding array value (2)"),
+        ],
+    )
+    def test_decode_broken_json_leak(self, broken_json, err_msg):
+        for _ in range(1000):
+            with pytest.raises(ValueError, match=re.escape(err_msg)):
+                ujson.ujson_loads(broken_json)
+
+    @pytest.mark.parametrize(
+        "invalid_dict",
+        [
+            "{{{{31337}}}}",  # No key.
+            '{{{{"key":}}}}',  # No value.
+            '{{{{"key"}}}}',  # No colon or value.
+        ],
+    )
+    def test_decode_invalid_dict(self, invalid_dict):
+        msg = (
+            "Key name of object must be 'string' when decoding 'object'|"
+            "No ':' found when decoding object value|"
+            "Expected object or value"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(invalid_dict)
+
+    @pytest.mark.parametrize("numeric_int_as_str", ["31337", "-31337"])
+    def test_decode_numeric_int(self, numeric_int_as_str):
+        assert int(numeric_int_as_str) == ujson.ujson_loads(numeric_int_as_str)
+
+    def test_encode_null_character(self):
+        wrapped_input = "31337 \x00 1337"
+        output = ujson.ujson_dumps(wrapped_input)
+
+        assert wrapped_input == json.loads(output)
+        assert output == json.dumps(wrapped_input)
+        assert wrapped_input == ujson.ujson_loads(output)
+
+        alone_input = "\x00"
+        output = ujson.ujson_dumps(alone_input)
+
+        assert alone_input == json.loads(output)
+        assert output == json.dumps(alone_input)
+        assert alone_input == ujson.ujson_loads(output)
+        assert '"  \\u0000\\r\\n "' == ujson.ujson_dumps("  \u0000\r\n ")
+
+    def test_decode_null_character(self):
+        wrapped_input = '"31337 \\u0000 31337"'
+        assert ujson.ujson_loads(wrapped_input) == json.loads(wrapped_input)
+
+    def test_encode_list_long_conversion(self):
+        long_input = [
+            9223372036854775807,
+            9223372036854775807,
+            9223372036854775807,
+            9223372036854775807,
+            9223372036854775807,
+            9223372036854775807,
+        ]
+        output = ujson.ujson_dumps(long_input)
+
+        assert long_input == json.loads(output)
+        assert long_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize("long_input", [9223372036854775807, 18446744073709551615])
+    def test_encode_long_conversion(self, long_input):
+        output = ujson.ujson_dumps(long_input)
+
+        assert long_input == json.loads(output)
+        assert output == json.dumps(long_input)
+        assert long_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize("bigNum", [2**64, -(2**63) - 1])
+    def test_dumps_ints_larger_than_maxsize(self, bigNum):
+        encoding = ujson.ujson_dumps(bigNum)
+        assert str(bigNum) == encoding
+
+        with pytest.raises(
+            ValueError,
+            match="Value is too big|Value is too small",
+        ):
+            assert ujson.ujson_loads(encoding) == bigNum
+
+    @pytest.mark.parametrize(
+        "int_exp", ["1337E40", "1.337E40", "1337E+9", "1.337e+40", "1.337E-4"]
+    )
+    def test_decode_numeric_int_exp(self, int_exp):
+        assert ujson.ujson_loads(int_exp) == json.loads(int_exp)
+
+    def test_loads_non_str_bytes_raises(self):
+        msg = "a bytes-like object is required, not 'NoneType'"
+        with pytest.raises(TypeError, match=msg):
+            ujson.ujson_loads(None)
+
+    @pytest.mark.parametrize("val", [3590016419, 2**31, 2**32, (2**32) - 1])
+    def test_decode_number_with_32bit_sign_bit(self, val):
+        # Test that numbers that fit within 32 bits but would have the
+        # sign bit set (2**31 <= x < 2**32) are decoded properly.
+        doc = f'{{"id": {val}}}'
+        assert ujson.ujson_loads(doc)["id"] == val
+
+    def test_encode_big_escape(self):
+        # Make sure no Exception is raised.
+        for _ in range(10):
+            base = "\u00e5".encode()
+            escape_input = base * 1024 * 1024 * 2
+            ujson.ujson_dumps(escape_input)
+
+    def test_decode_big_escape(self):
+        # Make sure no Exception is raised.
+        for _ in range(10):
+            base = "\u00e5".encode()
+            quote = b'"'
+
+            escape_input = quote + (base * 1024 * 1024 * 2) + quote
+            ujson.ujson_loads(escape_input)
+
+    def test_to_dict(self):
+        d = {"key": 31337}
+
+        class DictTest:
+            def toDict(self):
+                return d
+
+        o = DictTest()
+        output = ujson.ujson_dumps(o)
+
+        dec = ujson.ujson_loads(output)
+        assert dec == d
+
+    def test_default_handler(self):
+        class _TestObject:
+            def __init__(self, val) -> None:
+                self.val = val
+
+            @property
+            def recursive_attr(self):
+                return _TestObject("recursive_attr")
+
+            def __str__(self) -> str:
+                return str(self.val)
+
+        msg = "Maximum recursion level reached"
+        with pytest.raises(OverflowError, match=msg):
+            ujson.ujson_dumps(_TestObject("foo"))
+        assert '"foo"' == ujson.ujson_dumps(_TestObject("foo"), default_handler=str)
+
+        def my_handler(_):
+            return "foobar"
+
+        assert '"foobar"' == ujson.ujson_dumps(
+            _TestObject("foo"), default_handler=my_handler
+        )
+
+        def my_handler_raises(_):
+            raise TypeError("I raise for anything")
+
+        with pytest.raises(TypeError, match="I raise for anything"):
+            ujson.ujson_dumps(_TestObject("foo"), default_handler=my_handler_raises)
+
+        def my_int_handler(_):
+            return 42
+
+        assert (
+            ujson.ujson_loads(
+                ujson.ujson_dumps(_TestObject("foo"), default_handler=my_int_handler)
+            )
+            == 42
+        )
+
+        def my_obj_handler(_):
+            return datetime.datetime(2013, 2, 3)
+
+        assert ujson.ujson_loads(
+            ujson.ujson_dumps(datetime.datetime(2013, 2, 3))
+        ) == ujson.ujson_loads(
+            ujson.ujson_dumps(_TestObject("foo"), default_handler=my_obj_handler)
+        )
+
+        obj_list = [_TestObject("foo"), _TestObject("bar")]
+        assert json.loads(json.dumps(obj_list, default=str)) == ujson.ujson_loads(
+            ujson.ujson_dumps(obj_list, default_handler=str)
+        )
+
+    def test_encode_object(self):
+        class _TestObject:
+            def __init__(self, a, b, _c, d) -> None:
+                self.a = a
+                self.b = b
+                self._c = _c
+                self.d = d
+
+            def e(self):
+                return 5
+
+        # JSON keys should be all non-callable non-underscore attributes, see GH-42768
+        test_object = _TestObject(a=1, b=2, _c=3, d=4)
+        assert ujson.ujson_loads(ujson.ujson_dumps(test_object)) == {
+            "a": 1,
+            "b": 2,
+            "d": 4,
+        }
+
+    def test_ujson__name__(self):
+        # GH 52898
+        assert ujson.__name__ == "pandas._libs.json"
+
+
+class TestNumpyJSONTests:
+    @pytest.mark.parametrize("bool_input", [True, False])
+    def test_bool(self, bool_input):
+        b = bool(bool_input)
+        assert ujson.ujson_loads(ujson.ujson_dumps(b)) == b
+
+    def test_bool_array(self):
+        bool_array = np.array(
+            [True, False, True, True, False, True, False, False], dtype=bool
+        )
+        output = np.array(ujson.ujson_loads(ujson.ujson_dumps(bool_array)), dtype=bool)
+        tm.assert_numpy_array_equal(bool_array, output)
+
+    def test_int(self, any_int_numpy_dtype):
+        klass = np.dtype(any_int_numpy_dtype).type
+        num = klass(1)
+
+        assert klass(ujson.ujson_loads(ujson.ujson_dumps(num))) == num
+
+    def test_int_array(self, any_int_numpy_dtype):
+        arr = np.arange(100, dtype=int)
+        arr_input = arr.astype(any_int_numpy_dtype)
+
+        arr_output = np.array(
+            ujson.ujson_loads(ujson.ujson_dumps(arr_input)), dtype=any_int_numpy_dtype
+        )
+        tm.assert_numpy_array_equal(arr_input, arr_output)
+
+    def test_int_max(self, any_int_numpy_dtype):
+        if any_int_numpy_dtype in ("int64", "uint64") and not IS64:
+            pytest.skip("Cannot test 64-bit integer on 32-bit platform")
+
+        klass = np.dtype(any_int_numpy_dtype).type
+
+        # uint64 max will always overflow,
+        # as it's encoded to signed.
+        if any_int_numpy_dtype == "uint64":
+            num = np.iinfo("int64").max
+        else:
+            num = np.iinfo(any_int_numpy_dtype).max
+
+        assert klass(ujson.ujson_loads(ujson.ujson_dumps(num))) == num
+
+    def test_float(self, float_numpy_dtype):
+        klass = np.dtype(float_numpy_dtype).type
+        num = klass(256.2013)
+
+        assert klass(ujson.ujson_loads(ujson.ujson_dumps(num))) == num
+
+    def test_float_array(self, float_numpy_dtype):
+        arr = np.arange(12.5, 185.72, 1.7322, dtype=float)
+        float_input = arr.astype(float_numpy_dtype)
+
+        float_output = np.array(
+            ujson.ujson_loads(ujson.ujson_dumps(float_input, double_precision=15)),
+            dtype=float_numpy_dtype,
+        )
+        tm.assert_almost_equal(float_input, float_output)
+
+    def test_float_max(self, float_numpy_dtype):
+        klass = np.dtype(float_numpy_dtype).type
+        num = klass(np.finfo(float_numpy_dtype).max / 10)
+
+        tm.assert_almost_equal(
+            klass(ujson.ujson_loads(ujson.ujson_dumps(num, double_precision=15))), num
+        )
+
+    def test_array_basic(self):
+        arr = np.arange(96)
+        arr = arr.reshape((2, 2, 2, 2, 3, 2))
+
+        tm.assert_numpy_array_equal(
+            np.array(ujson.ujson_loads(ujson.ujson_dumps(arr))), arr
+        )
+
+    @pytest.mark.parametrize("shape", [(10, 10), (5, 5, 4), (100, 1)])
+    def test_array_reshaped(self, shape):
+        arr = np.arange(100)
+        arr = arr.reshape(shape)
+
+        tm.assert_numpy_array_equal(
+            np.array(ujson.ujson_loads(ujson.ujson_dumps(arr))), arr
+        )
+
+    def test_array_list(self):
+        arr_list = [
+            "a",
+            [],
+            {},
+            {},
+            [],
+            42,
+            97.8,
+            ["a", "b"],
+            {"key": "val"},
+        ]
+        arr = np.array(arr_list, dtype=object)
+        result = np.array(ujson.ujson_loads(ujson.ujson_dumps(arr)), dtype=object)
+        tm.assert_numpy_array_equal(result, arr)
+
+    def test_array_float(self):
+        dtype = np.float32
+
+        arr = np.arange(100.202, 200.202, 1, dtype=dtype)
+        arr = arr.reshape((5, 5, 4))
+
+        arr_out = np.array(ujson.ujson_loads(ujson.ujson_dumps(arr)), dtype=dtype)
+        tm.assert_almost_equal(arr, arr_out)
+
+    def test_0d_array(self):
+        # gh-18878
+        msg = re.escape(
+            "array(1) (numpy-scalar) is not JSON serializable at the moment"
+        )
+        with pytest.raises(TypeError, match=msg):
+            ujson.ujson_dumps(np.array(1))
+
+    def test_array_long_double(self):
+        msg = re.compile(
+            "1234.5.* \\(numpy-scalar\\) is not JSON serializable at the moment"
+        )
+        with pytest.raises(TypeError, match=msg):
+            ujson.ujson_dumps(np.longdouble(1234.5))
+
+
+class TestPandasJSONTests:
+    def test_dataframe(self, orient):
+        dtype = np.int64
+
+        df = DataFrame(
+            [[1, 2, 3], [4, 5, 6]],
+            index=["a", "b"],
+            columns=["x", "y", "z"],
+            dtype=dtype,
+        )
+        encode_kwargs = {} if orient is None else {"orient": orient}
+        assert (df.dtypes == dtype).all()
+
+        output = ujson.ujson_loads(ujson.ujson_dumps(df, **encode_kwargs))
+        assert (df.dtypes == dtype).all()
+
+        # Ensure proper DataFrame initialization.
+        if orient == "split":
+            dec = _clean_dict(output)
+            output = DataFrame(**dec)
+        else:
+            output = DataFrame(output)
+
+        # Corrections to enable DataFrame comparison.
+        if orient == "values":
+            df.columns = [0, 1, 2]
+            df.index = [0, 1]
+        elif orient == "records":
+            df.index = [0, 1]
+        elif orient == "index":
+            df = df.transpose()
+
+        assert (df.dtypes == dtype).all()
+        tm.assert_frame_equal(output, df)
+
+    def test_dataframe_nested(self, orient):
+        df = DataFrame(
+            [[1, 2, 3], [4, 5, 6]], index=["a", "b"], columns=["x", "y", "z"]
+        )
+
+        nested = {"df1": df, "df2": df.copy()}
+        kwargs = {} if orient is None else {"orient": orient}
+
+        exp = {
+            "df1": ujson.ujson_loads(ujson.ujson_dumps(df, **kwargs)),
+            "df2": ujson.ujson_loads(ujson.ujson_dumps(df, **kwargs)),
+        }
+        assert ujson.ujson_loads(ujson.ujson_dumps(nested, **kwargs)) == exp
+
+    def test_series(self, orient):
+        dtype = np.int64
+        s = Series(
+            [10, 20, 30, 40, 50, 60],
+            name="series",
+            index=[6, 7, 8, 9, 10, 15],
+            dtype=dtype,
+        ).sort_values()
+        assert s.dtype == dtype
+
+        encode_kwargs = {} if orient is None else {"orient": orient}
+
+        output = ujson.ujson_loads(ujson.ujson_dumps(s, **encode_kwargs))
+        assert s.dtype == dtype
+
+        if orient == "split":
+            dec = _clean_dict(output)
+            output = Series(**dec)
+        else:
+            output = Series(output)
+
+        if orient in (None, "index"):
+            s.name = None
+            output = output.sort_values()
+            s.index = ["6", "7", "8", "9", "10", "15"]
+        elif orient in ("records", "values"):
+            s.name = None
+            s.index = [0, 1, 2, 3, 4, 5]
+
+        assert s.dtype == dtype
+        tm.assert_series_equal(output, s)
+
+    def test_series_nested(self, orient):
+        s = Series(
+            [10, 20, 30, 40, 50, 60], name="series", index=[6, 7, 8, 9, 10, 15]
+        ).sort_values()
+        nested = {"s1": s, "s2": s.copy()}
+        kwargs = {} if orient is None else {"orient": orient}
+
+        exp = {
+            "s1": ujson.ujson_loads(ujson.ujson_dumps(s, **kwargs)),
+            "s2": ujson.ujson_loads(ujson.ujson_dumps(s, **kwargs)),
+        }
+        assert ujson.ujson_loads(ujson.ujson_dumps(nested, **kwargs)) == exp
+
+    def test_index(self):
+        i = Index([23, 45, 18, 98, 43, 11], name="index")
+
+        # Column indexed.
+        output = Index(ujson.ujson_loads(ujson.ujson_dumps(i)), name="index")
+        tm.assert_index_equal(i, output)
+
+        dec = _clean_dict(ujson.ujson_loads(ujson.ujson_dumps(i, orient="split")))
+        output = Index(**dec)
+
+        tm.assert_index_equal(i, output)
+        assert i.name == output.name
+
+        tm.assert_index_equal(i, output)
+        assert i.name == output.name
+
+        output = Index(
+            ujson.ujson_loads(ujson.ujson_dumps(i, orient="values")), name="index"
+        )
+        tm.assert_index_equal(i, output)
+
+        output = Index(
+            ujson.ujson_loads(ujson.ujson_dumps(i, orient="records")), name="index"
+        )
+        tm.assert_index_equal(i, output)
+
+        output = Index(
+            ujson.ujson_loads(ujson.ujson_dumps(i, orient="index")), name="index"
+        )
+        tm.assert_index_equal(i, output)
+
+    def test_datetime_index(self):
+        date_unit = "ns"
+
+        # freq doesn't round-trip
+        rng = DatetimeIndex(
+            list(date_range("1/1/2000", periods=20, unit="ns")), freq=None
+        )
+        encoded = ujson.ujson_dumps(rng, date_unit=date_unit)
+
+        decoded = DatetimeIndex(np.array(ujson.ujson_loads(encoded)))
+        tm.assert_index_equal(rng, decoded)
+
+        ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+        decoded = Series(ujson.ujson_loads(ujson.ujson_dumps(ts, date_unit=date_unit)))
+
+        idx_values = decoded.index.values.astype(np.int64)
+        decoded.index = DatetimeIndex(idx_values)
+        tm.assert_series_equal(ts, decoded)
+
+    @pytest.mark.parametrize(
+        "invalid_arr",
+        [
+            "[31337,]",  # Trailing comma.
+            "[,31337]",  # Leading comma.
+            "[]]",  # Unmatched bracket.
+            "[,]",  # Only comma.
+        ],
+    )
+    def test_decode_invalid_array(self, invalid_arr):
+        msg = (
+            "Expected object or value|Trailing data|"
+            "Unexpected character found when decoding array value"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(invalid_arr)
+
+    @pytest.mark.parametrize("arr", [[], [31337]])
+    def test_decode_array(self, arr):
+        assert arr == ujson.ujson_loads(str(arr))
+
+    @pytest.mark.parametrize("extreme_num", [9223372036854775807, -9223372036854775808])
+    def test_decode_extreme_numbers(self, extreme_num):
+        assert extreme_num == ujson.ujson_loads(str(extreme_num))
+
+    @pytest.mark.parametrize("too_extreme_num", [f"{2**64}", f"{-(2**63) - 1}"])
+    def test_decode_too_extreme_numbers(self, too_extreme_num):
+        with pytest.raises(
+            ValueError,
+            match="Value is too big|Value is too small",
+        ):
+            ujson.ujson_loads(too_extreme_num)
+
+    def test_decode_with_trailing_whitespaces(self):
+        assert {} == ujson.ujson_loads("{}\n\t ")
+
+    def test_decode_with_trailing_non_whitespaces(self):
+        with pytest.raises(ValueError, match="Trailing data"):
+            ujson.ujson_loads("{}\n\t a")
+
+    @pytest.mark.parametrize("value", [f"{2**64}", f"{-(2**63) - 1}"])
+    def test_decode_array_with_big_int(self, value):
+        with pytest.raises(
+            ValueError,
+            match="Value is too big|Value is too small",
+        ):
+            ujson.ujson_loads(value)
+
+    @pytest.mark.parametrize(
+        "float_number",
+        [
+            1.1234567893,
+            1.234567893,
+            1.34567893,
+            1.4567893,
+            1.567893,
+            1.67893,
+            1.7893,
+            1.893,
+            1.3,
+        ],
+    )
+    @pytest.mark.parametrize("sign", [-1, 1])
+    def test_decode_floating_point(self, sign, float_number):
+        float_number *= sign
+        tm.assert_almost_equal(
+            float_number, ujson.ujson_loads(str(float_number)), rtol=1e-15
+        )
+
+    def test_encode_big_set(self):
+        s = set(range(100000))
+        # Make sure no Exception is raised.
+        ujson.ujson_dumps(s)
+
+    def test_encode_empty_set(self):
+        assert "[]" == ujson.ujson_dumps(set())
+
+    def test_encode_set(self):
+        s = {1, 2, 3, 4, 5, 6, 7, 8, 9}
+        enc = ujson.ujson_dumps(s)
+        dec = ujson.ujson_loads(enc)
+
+        for v in dec:
+            assert v in s
+
+    @pytest.mark.parametrize(
+        "td",
+        [
+            Timedelta(days=366),
+            Timedelta(days=-1),
+            Timedelta(hours=13, minutes=5, seconds=5),
+            Timedelta(hours=13, minutes=20, seconds=30),
+            Timedelta(days=-1, nanoseconds=5),
+            Timedelta(nanoseconds=1),
+            Timedelta(microseconds=1, nanoseconds=1),
+            Timedelta(milliseconds=1, microseconds=1, nanoseconds=1),
+            Timedelta(milliseconds=999, microseconds=999, nanoseconds=999),
+        ],
+    )
+    def test_encode_timedelta_iso(self, td):
+        # GH 28256
+        result = ujson.ujson_dumps(td, iso_dates=True)
+        expected = f'"{td.isoformat()}"'
+
+        assert result == expected
+
+    def test_encode_periodindex(self):
+        # GH 46683
+        p = PeriodIndex(["2022-04-06", "2022-04-07"], freq="D")
+        df = DataFrame(index=p)
+        assert df.to_json() == "{}"

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_chunksize.py

@@ -0,0 +1,364 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+from io import StringIO
+
+import numpy as np
+import pytest
+
+from pandas._libs import parsers as libparsers
+from pandas.errors import DtypeWarning
+
+from pandas import (
+    DataFrame,
+    concat,
+)
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+@pytest.mark.parametrize("index_col", [0, "index"])
+def test_read_chunksize_with_index(all_parsers, index_col):
+    parser = all_parsers
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+
+    expected = DataFrame(
+        [
+            ["foo", 2, 3, 4, 5],
+            ["bar", 7, 8, 9, 10],
+            ["baz", 12, 13, 14, 15],
+            ["qux", 12, 13, 14, 15],
+            ["foo2", 12, 13, 14, 15],
+            ["bar2", 12, 13, 14, 15],
+        ],
+        columns=["index", "A", "B", "C", "D"],
+    )
+    expected = expected.set_index("index")
+
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            with parser.read_csv(StringIO(data), index_col=0, chunksize=2) as reader:
+                list(reader)
+        return
+
+    with parser.read_csv(StringIO(data), index_col=0, chunksize=2) as reader:
+        chunks = list(reader)
+    tm.assert_frame_equal(chunks[0], expected[:2])
+    tm.assert_frame_equal(chunks[1], expected[2:4])
+    tm.assert_frame_equal(chunks[2], expected[4:])
+
+
+@pytest.mark.parametrize("chunksize", [1.3, "foo", 0])
+def test_read_chunksize_bad(all_parsers, chunksize):
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+    parser = all_parsers
+    msg = r"'chunksize' must be an integer >=1"
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+
+    with pytest.raises(ValueError, match=msg):
+        with parser.read_csv(StringIO(data), chunksize=chunksize) as _:
+            pass
+
+
+@pytest.mark.parametrize("chunksize", [2, 8])
+def test_read_chunksize_and_nrows(all_parsers, chunksize):
+    # see gh-15755
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+    parser = all_parsers
+    kwargs = {"index_col": 0, "nrows": 5}
+
+    if parser.engine == "pyarrow":
+        msg = "The 'nrows' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), **kwargs)
+        return
+
+    expected = parser.read_csv(StringIO(data), **kwargs)
+    with parser.read_csv(StringIO(data), chunksize=chunksize, **kwargs) as reader:
+        tm.assert_frame_equal(concat(reader), expected)
+
+
+def test_read_chunksize_and_nrows_changing_size(all_parsers):
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+    parser = all_parsers
+    kwargs = {"index_col": 0, "nrows": 5}
+
+    if parser.engine == "pyarrow":
+        msg = "The 'nrows' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), **kwargs)
+        return
+
+    expected = parser.read_csv(StringIO(data), **kwargs)
+    with parser.read_csv(StringIO(data), chunksize=8, **kwargs) as reader:
+        tm.assert_frame_equal(reader.get_chunk(size=2), expected.iloc[:2])
+        tm.assert_frame_equal(reader.get_chunk(size=4), expected.iloc[2:5])
+
+        with pytest.raises(StopIteration, match="^$"):
+            reader.get_chunk(size=3)
+
+
+def test_get_chunk_passed_chunksize(all_parsers):
+    parser = all_parsers
+    data = """A,B,C
+1,2,3
+4,5,6
+7,8,9
+1,2,3"""
+
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            with parser.read_csv(StringIO(data), chunksize=2) as reader:
+                reader.get_chunk()
+        return
+
+    with parser.read_csv(StringIO(data), chunksize=2) as reader:
+        result = reader.get_chunk()
+
+    expected = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["A", "B", "C"])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("kwargs", [{}, {"index_col": 0}])
+def test_read_chunksize_compat(all_parsers, kwargs):
+    # see gh-12185
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), **kwargs)
+
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            with parser.read_csv(StringIO(data), chunksize=2, **kwargs) as reader:
+                concat(reader)
+        return
+
+    with parser.read_csv(StringIO(data), chunksize=2, **kwargs) as reader:
+        via_reader = concat(reader)
+    tm.assert_frame_equal(via_reader, result)
+
+
+def test_read_chunksize_jagged_names(all_parsers):
+    # see gh-23509
+    parser = all_parsers
+    data = "\n".join(["0"] * 7 + [",".join(["0"] * 10)])
+
+    expected = DataFrame([[0] + [np.nan] * 9] * 7 + [[0] * 10])
+
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            with parser.read_csv(
+                StringIO(data), names=range(10), chunksize=4
+            ) as reader:
+                concat(reader)
+        return
+
+    with parser.read_csv(StringIO(data), names=range(10), chunksize=4) as reader:
+        result = concat(reader)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_chunk_begins_with_newline_whitespace(all_parsers):
+    # see gh-10022
+    parser = all_parsers
+    data = "\n hello\nworld\n"
+
+    result = parser.read_csv(StringIO(data), header=None)
+    expected = DataFrame([" hello", "world"])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.slow
+def test_chunks_have_consistent_numerical_type(all_parsers, monkeypatch):
+    # mainly an issue with the C parser
+    heuristic = 2**3
+    parser = all_parsers
+    integers = [str(i) for i in range(heuristic - 1)]
+    data = "a\n" + "\n".join([*integers, "1.0", "2.0", *integers])
+
+    # Coercions should work without warnings.
+    with monkeypatch.context() as m:
+        m.setattr(libparsers, "DEFAULT_BUFFER_HEURISTIC", heuristic)
+        result = parser.read_csv(StringIO(data))
+
+    assert type(result.a[0]) is np.float64
+    assert result.a.dtype == float
+
+
+def test_warn_if_chunks_have_mismatched_type(
+    all_parsers, using_infer_string, monkeypatch
+):
+    warning_type = None
+    parser = all_parsers
+    heuristic = 2**3
+    size = 10
+
+    # see gh-3866: if chunks are different types and can't
+    # be coerced using numerical types, then issue warning.
+    if parser.engine == "c" and parser.low_memory:
+        warning_type = DtypeWarning
+        # Use a size to hit warning path dictated by DEFAULT_BUFFER_HEURISTIC
+        # monkeypatched below
+        size = heuristic - 1
+
+    integers = [str(i) for i in range(size)]
+    data = "a\n" + "\n".join([*integers, "a", "b", *integers])
+
+    buf = StringIO(data)
+
+    if parser.engine == "pyarrow":
+        df = parser.read_csv(
+            buf,
+        )
+    else:
+        with monkeypatch.context() as m:
+            m.setattr(libparsers, "DEFAULT_BUFFER_HEURISTIC", heuristic)
+            df = parser.read_csv_check_warnings(
+                warning_type,
+                r"Columns \(0: a\) have mixed types. "
+                "Specify dtype option on import or set low_memory=False.",
+                buf,
+            )
+    if parser.engine == "c" and parser.low_memory:
+        assert df.a.dtype == object
+    elif using_infer_string:
+        assert df.a.dtype == "str"
+    else:
+        assert df.a.dtype == object
+
+
+@pytest.mark.parametrize("iterator", [True, False])
+def test_empty_with_nrows_chunksize(all_parsers, iterator):
+    # see gh-9535
+    parser = all_parsers
+    expected = DataFrame(columns=["foo", "bar"])
+
+    nrows = 10
+    data = StringIO("foo,bar\n")
+
+    if parser.engine == "pyarrow":
+        msg = (
+            "The '(nrows|chunksize)' option is not supported with the 'pyarrow' engine"
+        )
+        with pytest.raises(ValueError, match=msg):
+            if iterator:
+                with parser.read_csv(data, chunksize=nrows) as reader:
+                    next(iter(reader))
+            else:
+                parser.read_csv(data, nrows=nrows)
+        return
+
+    if iterator:
+        with parser.read_csv(data, chunksize=nrows) as reader:
+            result = next(iter(reader))
+    else:
+        result = parser.read_csv(data, nrows=nrows)
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_chunksize_with_usecols_second_block_shorter(all_parsers):
+    # GH#21211
+    parser = all_parsers
+    data = """1,2,3,4
+5,6,7,8
+9,10,11
+"""
+
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(
+                StringIO(data),
+                names=["a", "b"],
+                chunksize=2,
+                usecols=[0, 1],
+                header=None,
+            )
+        return
+
+    result_chunks = parser.read_csv(
+        StringIO(data),
+        names=["a", "b"],
+        chunksize=2,
+        usecols=[0, 1],
+        header=None,
+    )
+
+    expected_frames = [
+        DataFrame({"a": [1, 5], "b": [2, 6]}),
+        DataFrame({"a": [9], "b": [10]}, index=[2]),
+    ]
+
+    for i, result in enumerate(result_chunks):
+        tm.assert_frame_equal(result, expected_frames[i])
+
+
+def test_chunksize_second_block_shorter(all_parsers):
+    # GH#21211
+    parser = all_parsers
+    data = """a,b,c,d
+1,2,3,4
+5,6,7,8
+9,10,11
+"""
+
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), chunksize=2)
+        return
+
+    result_chunks = parser.read_csv(StringIO(data), chunksize=2)
+
+    expected_frames = [
+        DataFrame({"a": [1, 5], "b": [2, 6], "c": [3, 7], "d": [4, 8]}),
+        DataFrame({"a": [9], "b": [10], "c": [11], "d": [np.nan]}, index=[2]),
+    ]
+
+    for i, result in enumerate(result_chunks):
+        tm.assert_frame_equal(result, expected_frames[i])

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_common_basic.py

@@ -0,0 +1,868 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+from datetime import datetime
+from inspect import signature
+from io import StringIO
+import os
+import sys
+
+import numpy as np
+import pytest
+
+from pandas._config import using_string_dtype
+
+from pandas.compat import HAS_PYARROW
+from pandas.errors import (
+    EmptyDataError,
+    ParserError,
+    ParserWarning,
+)
+
+from pandas import (
+    DataFrame,
+    Index,
+    compat,
+)
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
+
+
+def test_read_csv_local(all_parsers, csv1):
+    prefix = "file:///" if compat.is_platform_windows() else "file://"
+    parser = all_parsers
+
+    fname = prefix + str(os.path.abspath(csv1))
+    result = parser.read_csv(fname, index_col=0, parse_dates=True)
+
+    expected = DataFrame(
+        [
+            [0.980269, 3.685731, -0.364216805298, -1.159738],
+            [1.047916, -0.041232, -0.16181208307, 0.212549],
+            [0.498581, 0.731168, -0.537677223318, 1.346270],
+            [1.120202, 1.567621, 0.00364077397681, 0.675253],
+            [-0.487094, 0.571455, -1.6116394093, 0.103469],
+            [0.836649, 0.246462, 0.588542635376, 1.062782],
+            [-0.157161, 1.340307, 1.1957779562, -1.097007],
+        ],
+        columns=["A", "B", "C", "D"],
+        index=Index(
+            [
+                datetime(2000, 1, 3),
+                datetime(2000, 1, 4),
+                datetime(2000, 1, 5),
+                datetime(2000, 1, 6),
+                datetime(2000, 1, 7),
+                datetime(2000, 1, 10),
+                datetime(2000, 1, 11),
+            ],
+            dtype="M8[us]",
+            name="index",
+        ),
+    )
+    if parser.engine == "pyarrow":
+        expected.index = expected.index.astype("M8[s]")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "number_csv, expected_number",
+    [
+        ("2,334", 2334),
+        ("-2,334", -2334),
+        ("-2,334,", -2334),
+        # Multiple consecutive thousand separators are allowed in C engine,
+        # but it's not necessarily intended behavior and may change in the future.
+        ("2,,,,,,,,,,,,,,,5", 25),
+        ("2,,3,4,,,,,,,,,,,,5", 2345),
+    ],
+)
+def test_1000_sep(all_parsers, number_csv, expected_number, request):
+    parser = all_parsers
+    data = f"""A|B|C
+1|{number_csv}|5
+10|13|10.
+"""
+    expected = DataFrame({"A": [1, 10], "B": [expected_number, 13], "C": [5, 10.0]})
+
+    if parser.engine == "pyarrow":
+        msg = "The 'thousands' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), sep="|", thousands=",")
+        return
+    elif parser.engine == "python" and ",," in number_csv:
+        mark = pytest.mark.xfail(
+            reason="Python engine doesn't allow consecutive thousands separators"
+        )
+        request.applymarker(mark)
+
+    result = parser.read_csv(StringIO(data), sep="|", thousands=",")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("value", ["1 ,", ", 1", ",1"])
+def test_1000_sep_not_stripped_after_whitespace(all_parsers, value):
+    parser = all_parsers
+    data = f"a\n{value}\n"
+    expected = DataFrame({"a": [value]})
+
+    if parser.engine == "pyarrow":
+        msg = "The 'thousands' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), sep=";", thousands=",")
+        return
+
+    result = parser.read_csv(StringIO(data), sep=";", thousands=",")
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow  # ValueError: Found non-unique column index
+def test_unnamed_columns(all_parsers):
+    data = """A,B,C,,
+1,2,3,4,5
+6,7,8,9,10
+11,12,13,14,15
+"""
+    parser = all_parsers
+    expected = DataFrame(
+        [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]],
+        dtype=np.int64,
+        columns=["A", "B", "C", "Unnamed: 3", "Unnamed: 4"],
+    )
+    result = parser.read_csv(StringIO(data))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_csv_mixed_type(all_parsers):
+    data = """A,B,C
+a,1,2
+b,3,4
+c,4,5
+"""
+    parser = all_parsers
+    expected = DataFrame({"A": ["a", "b", "c"], "B": [1, 3, 4], "C": [2, 4, 5]})
+    result = parser.read_csv(StringIO(data))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_csv_low_memory_no_rows_with_index(all_parsers):
+    # see gh-21141
+    parser = all_parsers
+
+    if not parser.low_memory:
+        pytest.skip("This is a low-memory specific test")
+
+    data = """A,B,C
+1,1,1,2
+2,2,3,4
+3,3,4,5
+"""
+
+    if parser.engine == "pyarrow":
+        msg = "The 'nrows' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), low_memory=True, index_col=0, nrows=0)
+        return
+
+    result = parser.read_csv(StringIO(data), low_memory=True, index_col=0, nrows=0)
+    expected = DataFrame(columns=["A", "B", "C"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_csv_dataframe(all_parsers, csv1):
+    parser = all_parsers
+    result = parser.read_csv(csv1, index_col=0, parse_dates=True)
+    expected = DataFrame(
+        [
+            [0.980269, 3.685731, -0.364216805298, -1.159738],
+            [1.047916, -0.041232, -0.16181208307, 0.212549],
+            [0.498581, 0.731168, -0.537677223318, 1.346270],
+            [1.120202, 1.567621, 0.00364077397681, 0.675253],
+            [-0.487094, 0.571455, -1.6116394093, 0.103469],
+            [0.836649, 0.246462, 0.588542635376, 1.062782],
+            [-0.157161, 1.340307, 1.1957779562, -1.097007],
+        ],
+        columns=["A", "B", "C", "D"],
+        index=Index(
+            [
+                datetime(2000, 1, 3),
+                datetime(2000, 1, 4),
+                datetime(2000, 1, 5),
+                datetime(2000, 1, 6),
+                datetime(2000, 1, 7),
+                datetime(2000, 1, 10),
+                datetime(2000, 1, 11),
+            ],
+            dtype="M8[us]",
+            name="index",
+        ),
+    )
+    if parser.engine == "pyarrow":
+        expected.index = expected.index.astype("M8[s]")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("nrows", [3, 3.0])
+def test_read_nrows(all_parsers, nrows):
+    # see gh-10476
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+    expected = DataFrame(
+        [["foo", 2, 3, 4, 5], ["bar", 7, 8, 9, 10], ["baz", 12, 13, 14, 15]],
+        columns=["index", "A", "B", "C", "D"],
+    )
+    parser = all_parsers
+
+    if parser.engine == "pyarrow":
+        msg = "The 'nrows' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), nrows=nrows)
+        return
+
+    result = parser.read_csv(StringIO(data), nrows=nrows)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("nrows", [1.2, "foo", -1])
+def test_read_nrows_bad(all_parsers, nrows):
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+    msg = r"'nrows' must be an integer >=0"
+    parser = all_parsers
+    if parser.engine == "pyarrow":
+        msg = "The 'nrows' option is not supported with the 'pyarrow' engine"
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(StringIO(data), nrows=nrows)
+
+
+def test_nrows_skipfooter_errors(all_parsers):
+    msg = "'skipfooter' not supported with 'nrows'"
+    data = "a\n1\n2\n3\n4\n5\n6"
+    parser = all_parsers
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(StringIO(data), skipfooter=1, nrows=5)
+
+
+@skip_pyarrow
+def test_missing_trailing_delimiters(all_parsers):
+    parser = all_parsers
+    data = """A,B,C,D
+1,2,3,4
+1,3,3,
+1,4,5"""
+
+    result = parser.read_csv(StringIO(data))
+    expected = DataFrame(
+        [[1, 2, 3, 4], [1, 3, 3, np.nan], [1, 4, 5, np.nan]],
+        columns=["A", "B", "C", "D"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_skip_initial_space(all_parsers):
+    data = (
+        '"09-Apr-2012", "01:10:18.300", 2456026.548822908, 12849, '
+        "1.00361,  1.12551, 330.65659, 0355626618.16711,  73.48821, "
+        "314.11625,  1917.09447,   179.71425,  80.000, 240.000, -350,  "
+        "70.06056, 344.98370, 1,   1, -0.689265, -0.692787,  "
+        "0.212036,    14.7674,   41.605,   -9999.0,   -9999.0,   "
+        "-9999.0,   -9999.0,   -9999.0,  -9999.0, 000, 012, 128"
+    )
+    parser = all_parsers
+
+    if parser.engine == "pyarrow":
+        msg = "The 'skipinitialspace' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(
+                StringIO(data),
+                names=list(range(33)),
+                header=None,
+                na_values=["-9999.0"],
+                skipinitialspace=True,
+            )
+        return
+
+    result = parser.read_csv(
+        StringIO(data),
+        names=list(range(33)),
+        header=None,
+        na_values=["-9999.0"],
+        skipinitialspace=True,
+    )
+    expected = DataFrame(
+        [
+            [
+                "09-Apr-2012",
+                "01:10:18.300",
+                2456026.548822908,
+                12849,
+                1.00361,
+                1.12551,
+                330.65659,
+                355626618.16711,
+                73.48821,
+                314.11625,
+                1917.09447,
+                179.71425,
+                80.0,
+                240.0,
+                -350,
+                70.06056,
+                344.9837,
+                1,
+                1,
+                -0.689265,
+                -0.692787,
+                0.212036,
+                14.7674,
+                41.605,
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                np.nan,
+                0,
+                12,
+                128,
+            ]
+        ]
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_trailing_delimiters(all_parsers):
+    # see gh-2442
+    data = """A,B,C
+1,2,3,
+4,5,6,
+7,8,9,"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), index_col=False)
+
+    expected = DataFrame({"A": [1, 4, 7], "B": [2, 5, 8], "C": [3, 6, 9]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_escapechar(all_parsers):
+    # https://stackoverflow.com/questions/13824840/feature-request-for-
+    # pandas-read-csv
+    data = '''SEARCH_TERM,ACTUAL_URL
+"bra tv board","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord"
+"tv p\xc3\xa5 hjul","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord"
+"SLAGBORD, \\"Bergslagen\\", IKEA:s 1700-tals series","http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord"'''
+
+    parser = all_parsers
+    result = parser.read_csv(
+        StringIO(data), escapechar="\\", quotechar='"', encoding="utf-8"
+    )
+
+    assert result["SEARCH_TERM"][2] == 'SLAGBORD, "Bergslagen", IKEA:s 1700-tals series'
+
+    tm.assert_index_equal(result.columns, Index(["SEARCH_TERM", "ACTUAL_URL"]))
+
+
+def test_ignore_leading_whitespace(all_parsers):
+    # see gh-3374, gh-6607
+    parser = all_parsers
+    data = " a b c\n 1 2 3\n 4 5 6\n 7 8 9"
+
+    if parser.engine == "pyarrow":
+        msg = "the 'pyarrow' engine does not support regex separators"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), sep=r"\s+")
+        return
+    result = parser.read_csv(StringIO(data), sep=r"\s+")
+
+    expected = DataFrame({"a": [1, 4, 7], "b": [2, 5, 8], "c": [3, 6, 9]})
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+@pytest.mark.parametrize("usecols", [None, [0, 1], ["a", "b"]])
+def test_uneven_lines_with_usecols(all_parsers, usecols):
+    # see gh-12203
+    parser = all_parsers
+    data = r"""a,b,c
+0,1,2
+3,4,5,6,7
+8,9,10"""
+
+    if usecols is None:
+        # Make sure that an error is still raised
+        # when the "usecols" parameter is not provided.
+        msg = r"Expected \d+ fields in line \d+, saw \d+"
+        with pytest.raises(ParserError, match=msg):
+            parser.read_csv(StringIO(data))
+    else:
+        expected = DataFrame({"a": [0, 3, 8], "b": [1, 4, 9]})
+
+        result = parser.read_csv(StringIO(data), usecols=usecols)
+        tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+@pytest.mark.parametrize(
+    "data,kwargs,expected",
+    [
+        # First, check to see that the response of parser when faced with no
+        # provided columns raises the correct error, with or without usecols.
+        ("", {}, None),
+        ("", {"usecols": ["X"]}, None),
+        (
+            ",,",
+            {"names": ["Dummy", "X", "Dummy_2"], "usecols": ["X"]},
+            DataFrame(columns=["X"], index=[0], dtype=np.float64),
+        ),
+        (
+            "",
+            {"names": ["Dummy", "X", "Dummy_2"], "usecols": ["X"]},
+            DataFrame(columns=["X"]),
+        ),
+    ],
+)
+def test_read_empty_with_usecols(all_parsers, data, kwargs, expected):
+    # see gh-12493
+    parser = all_parsers
+
+    if expected is None:
+        msg = "No columns to parse from file"
+        with pytest.raises(EmptyDataError, match=msg):
+            parser.read_csv(StringIO(data), **kwargs)
+    else:
+        result = parser.read_csv(StringIO(data), **kwargs)
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "kwargs,expected_data",
+    [
+        # gh-8661, gh-8679: this should ignore six lines, including
+        # lines with trailing whitespace and blank lines.
+        (
+            {
+                "header": None,
+                "sep": r"\s+",
+                "skiprows": [0, 1, 2, 3, 5, 6],
+                "skip_blank_lines": True,
+            },
+            [[1.0, 2.0, 4.0], [5.1, np.nan, 10.0]],
+        ),
+        # gh-8983: test skipping set of rows after a row with trailing spaces.
+        (
+            {
+                "sep": r"\s+",
+                "skiprows": [1, 2, 3, 5, 6],
+                "skip_blank_lines": True,
+            },
+            {"A": [1.0, 5.1], "B": [2.0, np.nan], "C": [4.0, 10]},
+        ),
+    ],
+)
+def test_trailing_spaces(all_parsers, kwargs, expected_data):
+    data = "A B C  \nrandom line with trailing spaces    \nskip\n1,2,3\n1,2.,4.\nrandom line with trailing tabs\t\t\t\n   \n5.1,NaN,10.0\n"  # noqa: E501
+    parser = all_parsers
+
+    if parser.engine == "pyarrow":
+        with pytest.raises(ValueError, match="the 'pyarrow' engine does not support"):
+            parser.read_csv(StringIO(data.replace(",", "  ")), **kwargs)
+        return
+    expected = DataFrame(expected_data)
+    result = parser.read_csv(StringIO(data.replace(",", "  ")), **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_filepath_or_buffer(all_parsers):
+    # see gh-43366
+    parser = all_parsers
+
+    with pytest.raises(TypeError, match="Expected file path name or file-like"):
+        parser.read_csv(filepath_or_buffer=b"input")
+
+
+def test_single_char_leading_whitespace(all_parsers):
+    # see gh-9710
+    parser = all_parsers
+    data = """\
+MyColumn
+a
+b
+a
+b\n"""
+
+    if parser.engine == "pyarrow":
+        msg = "The 'skipinitialspace' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(
+                StringIO(data),
+                skipinitialspace=True,
+            )
+        return
+    expected = DataFrame({"MyColumn": list("abab")})
+    result = parser.read_csv(StringIO(data), skipinitialspace=True, sep=r"\s+")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "sep,skip_blank_lines,exp_data",
+    [
+        (",", True, [[1.0, 2.0, 4.0], [5.0, np.nan, 10.0], [-70.0, 0.4, 1.0]]),
+        (r"\s+", True, [[1.0, 2.0, 4.0], [5.0, np.nan, 10.0], [-70.0, 0.4, 1.0]]),
+        (
+            ",",
+            False,
+            [
+                [1.0, 2.0, 4.0],
+                [np.nan, np.nan, np.nan],
+                [np.nan, np.nan, np.nan],
+                [5.0, np.nan, 10.0],
+                [np.nan, np.nan, np.nan],
+                [-70.0, 0.4, 1.0],
+            ],
+        ),
+    ],
+)
+def test_empty_lines(all_parsers, sep, skip_blank_lines, exp_data, request):
+    parser = all_parsers
+    data = """\
+A,B,C
+1,2.,4.
+
+
+5.,NaN,10.0
+
+-70,.4,1
+"""
+
+    if sep == r"\s+":
+        data = data.replace(",", "  ")
+
+        if parser.engine == "pyarrow":
+            msg = "the 'pyarrow' engine does not support regex separators"
+            with pytest.raises(ValueError, match=msg):
+                parser.read_csv(
+                    StringIO(data), sep=sep, skip_blank_lines=skip_blank_lines
+                )
+            return
+
+    result = parser.read_csv(StringIO(data), sep=sep, skip_blank_lines=skip_blank_lines)
+    expected = DataFrame(exp_data, columns=["A", "B", "C"])
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_whitespace_lines(all_parsers):
+    parser = all_parsers
+    data = """
+
+\t  \t\t
+\t
+A,B,C
+\t    1,2.,4.
+5.,NaN,10.0
+"""
+    expected = DataFrame([[1, 2.0, 4.0], [5.0, np.nan, 10.0]], columns=["A", "B", "C"])
+    result = parser.read_csv(StringIO(data))
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data,expected",
+    [
+        (
+            """   A   B   C   D
+a   1   2   3   4
+b   1   2   3   4
+c   1   2   3   4
+""",
+            DataFrame(
+                [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]],
+                columns=["A", "B", "C", "D"],
+                index=["a", "b", "c"],
+            ),
+        ),
+        (
+            "    a b c\n1 2 3 \n4 5  6\n 7 8 9",
+            DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=["a", "b", "c"]),
+        ),
+    ],
+)
+def test_whitespace_regex_separator(all_parsers, data, expected):
+    # see gh-6607
+    parser = all_parsers
+    if parser.engine == "pyarrow":
+        msg = "the 'pyarrow' engine does not support regex separators"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), sep=r"\s+")
+        return
+
+    result = parser.read_csv(StringIO(data), sep=r"\s+")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_sub_character(all_parsers, csv_dir_path):
+    # see gh-16893
+    filename = os.path.join(csv_dir_path, "sub_char.csv")
+    expected = DataFrame([[1, 2, 3]], columns=["a", "\x1ab", "c"])
+
+    parser = all_parsers
+    result = parser.read_csv(filename)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("filename", ["sé-es-vé.csv", "ru-sй.csv", "中文文件名.csv"])
+def test_filename_with_special_chars(all_parsers, filename, tmp_path):
+    # see gh-15086.
+    parser = all_parsers
+    df = DataFrame({"a": [1, 2, 3]})
+
+    path = tmp_path / filename
+    df.to_csv(path, index=False)
+
+    result = parser.read_csv(path)
+    tm.assert_frame_equal(result, df)
+
+
+def test_read_table_same_signature_as_read_csv(all_parsers):
+    # GH-34976
+    parser = all_parsers
+
+    table_sign = signature(parser.read_table)
+    csv_sign = signature(parser.read_csv)
+
+    assert table_sign.parameters.keys() == csv_sign.parameters.keys()
+    assert table_sign.return_annotation == csv_sign.return_annotation
+
+    for key, csv_param in csv_sign.parameters.items():
+        table_param = table_sign.parameters[key]
+        if key == "sep":
+            assert csv_param.default == ","
+            assert table_param.default == "\t"
+            assert table_param.annotation == csv_param.annotation
+            assert table_param.kind == csv_param.kind
+            continue
+
+        assert table_param == csv_param
+
+
+def test_read_table_equivalency_to_read_csv(all_parsers):
+    # see gh-21948
+    # As of 0.25.0, read_table is undeprecated
+    parser = all_parsers
+    data = "a\tb\n1\t2\n3\t4"
+    expected = parser.read_csv(StringIO(data), sep="\t")
+    result = parser.read_table(StringIO(data))
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("read_func", ["read_csv", "read_table"])
+def test_read_csv_and_table_sys_setprofile(all_parsers, read_func):
+    # GH#41069
+    parser = all_parsers
+    data = "a b\n0 1"
+
+    sys.setprofile(lambda *a, **k: None)
+    result = getattr(parser, read_func)(StringIO(data))
+    sys.setprofile(None)
+
+    expected = DataFrame({"a b": ["0 1"]})
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_first_row_bom(all_parsers):
+    # see gh-26545
+    parser = all_parsers
+    data = '''\ufeff"Head1"\t"Head2"\t"Head3"'''
+
+    result = parser.read_csv(StringIO(data), delimiter="\t")
+    expected = DataFrame(columns=["Head1", "Head2", "Head3"])
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_first_row_bom_unquoted(all_parsers):
+    # see gh-36343
+    parser = all_parsers
+    data = """\ufeffHead1\tHead2\tHead3"""
+
+    result = parser.read_csv(StringIO(data), delimiter="\t")
+    expected = DataFrame(columns=["Head1", "Head2", "Head3"])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("nrows", range(1, 6))
+def test_blank_lines_between_header_and_data_rows(all_parsers, nrows):
+    # GH 28071
+    ref = DataFrame(
+        [[np.nan, np.nan], [np.nan, np.nan], [1, 2], [np.nan, np.nan], [3, 4]],
+        columns=list("ab"),
+    )
+    csv = "\nheader\n\na,b\n\n\n1,2\n\n3,4"
+    parser = all_parsers
+
+    if parser.engine == "pyarrow":
+        msg = "The 'nrows' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(
+                StringIO(csv), header=3, nrows=nrows, skip_blank_lines=False
+            )
+        return
+
+    df = parser.read_csv(StringIO(csv), header=3, nrows=nrows, skip_blank_lines=False)
+    tm.assert_frame_equal(df, ref[:nrows])
+
+
+@skip_pyarrow
+def test_no_header_two_extra_columns(all_parsers):
+    # GH 26218
+    column_names = ["one", "two", "three"]
+    ref = DataFrame([["foo", "bar", "baz"]], columns=column_names)
+    stream = StringIO("foo,bar,baz,bam,blah")
+    parser = all_parsers
+    df = parser.read_csv_check_warnings(
+        ParserWarning,
+        "Length of header or names does not match length of data. "
+        "This leads to a loss of data with index_col=False.",
+        stream,
+        header=None,
+        names=column_names,
+        index_col=False,
+    )
+    tm.assert_frame_equal(df, ref)
+
+
+def test_read_csv_names_not_accepting_sets(all_parsers):
+    # GH 34946
+    data = """\
+    1,2,3
+    4,5,6\n"""
+    parser = all_parsers
+    with pytest.raises(ValueError, match="Names should be an ordered collection."):
+        parser.read_csv(StringIO(data), names=set("QAZ"))
+
+
+def test_read_csv_delimiter_and_sep_no_default(all_parsers):
+    # GH#39823
+    f = StringIO("a,b\n1,2")
+    parser = all_parsers
+    msg = "Specified a sep and a delimiter; you can only specify one."
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(f, sep=" ", delimiter=".")
+
+
+@pytest.mark.parametrize("kwargs", [{"delimiter": "\n"}, {"sep": "\n"}])
+def test_read_csv_line_break_as_separator(kwargs, all_parsers):
+    # GH#43528
+    parser = all_parsers
+    data = """a,b,c
+1,2,3
+    """
+    msg = (
+        r"Specified \\n as separator or delimiter. This forces the python engine "
+        r"which does not accept a line terminator. Hence it is not allowed to use "
+        r"the line terminator as separator."
+    )
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(StringIO(data), **kwargs)
+
+
+@skip_pyarrow
+def test_dict_keys_as_names(all_parsers):
+    # GH: 36928
+    data = "1,2"
+
+    keys = {"a": int, "b": int}.keys()
+    parser = all_parsers
+
+    result = parser.read_csv(StringIO(data), names=keys)
+    expected = DataFrame({"a": [1], "b": [2]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.xfail(using_string_dtype() and HAS_PYARROW, reason="TODO(infer_string)")
+@xfail_pyarrow  # UnicodeDecodeError: 'utf-8' codec can't decode byte 0xed in position 0
+def test_encoding_surrogatepass(all_parsers, tmp_path):
+    # GH39017
+    parser = all_parsers
+    content = b"\xed\xbd\xbf"
+    decoded = content.decode("utf-8", errors="surrogatepass")
+    expected = DataFrame({decoded: [decoded]}, index=[decoded * 2])
+    expected.index.name = decoded * 2
+
+    path = tmp_path / "test_encoding.csv"
+    path.write_bytes(
+        content * 2 + b"," + content + b"\n" + content * 2 + b"," + content
+    )
+    df = parser.read_csv(path, encoding_errors="surrogatepass", index_col=0)
+    tm.assert_frame_equal(df, expected)
+    with pytest.raises(UnicodeDecodeError, match="'utf-8' codec can't decode byte"):
+        parser.read_csv(path)
+
+
+def test_malformed_second_line(all_parsers):
+    # see GH14782
+    parser = all_parsers
+    data = "\na\nb\n"
+    result = parser.read_csv(StringIO(data), skip_blank_lines=False, header=1)
+    expected = DataFrame({"a": ["b"]})
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_short_single_line(all_parsers):
+    # GH 47566
+    parser = all_parsers
+    columns = ["a", "b", "c"]
+    data = "1,2"
+    result = parser.read_csv(StringIO(data), header=None, names=columns)
+    expected = DataFrame({"a": [1], "b": [2], "c": [np.nan]})
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow  # ValueError: Length mismatch: Expected axis has 2 elements
+def test_short_multi_line(all_parsers):
+    # GH 47566
+    parser = all_parsers
+    columns = ["a", "b", "c"]
+    data = "1,2\n1,2"
+    result = parser.read_csv(StringIO(data), header=None, names=columns)
+    expected = DataFrame({"a": [1, 1], "b": [2, 2], "c": [np.nan, np.nan]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_seek(all_parsers, tmp_path):
+    # GH48646
+    parser = all_parsers
+    prefix = "### DATA\n"
+    content = "nkey,value\ntables,rectangular\n"
+    path = tmp_path / "test_seek.csv"
+    path.write_text(prefix + content, encoding="utf-8")
+    with open(path, encoding="utf-8") as file:
+        file.readline()
+        actual = parser.read_csv(file)
+    expected = parser.read_csv(StringIO(content))
+    tm.assert_frame_equal(actual, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_data_list.py

@@ -0,0 +1,92 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+import csv
+from io import StringIO
+
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+from pandas.io.parsers import TextParser
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+
+
+@xfail_pyarrow
+def test_read_data_list(all_parsers):
+    parser = all_parsers
+    kwargs = {"index_col": 0}
+    data = "A,B,C\nfoo,1,2,3\nbar,4,5,6"
+
+    data_list = [["A", "B", "C"], ["foo", "1", "2", "3"], ["bar", "4", "5", "6"]]
+    expected = parser.read_csv(StringIO(data), **kwargs)
+
+    with TextParser(data_list, chunksize=2, **kwargs) as parser:
+        result = parser.read()
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reader_list(all_parsers):
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+    parser = all_parsers
+    kwargs = {"index_col": 0}
+
+    lines = list(csv.reader(StringIO(data)))
+    with TextParser(lines, chunksize=2, **kwargs) as reader:
+        chunks = list(reader)
+
+    expected = parser.read_csv(StringIO(data), **kwargs)
+
+    tm.assert_frame_equal(chunks[0], expected[:2])
+    tm.assert_frame_equal(chunks[1], expected[2:4])
+    tm.assert_frame_equal(chunks[2], expected[4:])
+
+
+def test_reader_list_skiprows(all_parsers):
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+    parser = all_parsers
+    kwargs = {"index_col": 0}
+
+    lines = list(csv.reader(StringIO(data)))
+    with TextParser(lines, chunksize=2, skiprows=[1], **kwargs) as reader:
+        chunks = list(reader)
+
+    expected = parser.read_csv(StringIO(data), **kwargs)
+
+    tm.assert_frame_equal(chunks[0], expected[1:3])
+
+
+def test_read_csv_parse_simple_list(all_parsers):
+    parser = all_parsers
+    data = """foo
+bar baz
+qux foo
+foo
+bar"""
+
+    result = parser.read_csv(StringIO(data), header=None)
+    expected = DataFrame(["foo", "bar baz", "qux foo", "foo", "bar"])
+    tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_decimal.py

@@ -0,0 +1,73 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+from io import StringIO
+
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+@pytest.mark.parametrize(
+    "data,thousands,decimal",
+    [
+        (
+            """A|B|C
+1|2,334.01|5
+10|13|10.
+""",
+            ",",
+            ".",
+        ),
+        (
+            """A|B|C
+1|2.334,01|5
+10|13|10,
+""",
+            ".",
+            ",",
+        ),
+    ],
+)
+def test_1000_sep_with_decimal(all_parsers, data, thousands, decimal):
+    parser = all_parsers
+    expected = DataFrame({"A": [1, 10], "B": [2334.01, 13], "C": [5, 10.0]})
+
+    if parser.engine == "pyarrow":
+        msg = "The 'thousands' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(
+                StringIO(data), sep="|", thousands=thousands, decimal=decimal
+            )
+        return
+
+    result = parser.read_csv(
+        StringIO(data), sep="|", thousands=thousands, decimal=decimal
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_euro_decimal_format(all_parsers):
+    parser = all_parsers
+    data = """Id;Number1;Number2;Text1;Text2;Number3
+1;1521,1541;187101,9543;ABC;poi;4,738797819
+2;121,12;14897,76;DEF;uyt;0,377320872
+3;878,158;108013,434;GHI;rez;2,735694704"""
+
+    result = parser.read_csv(StringIO(data), sep=";", decimal=",")
+    expected = DataFrame(
+        [
+            [1, 1521.1541, 187101.9543, "ABC", "poi", 4.738797819],
+            [2, 121.12, 14897.76, "DEF", "uyt", 0.377320872],
+            [3, 878.158, 108013.434, "GHI", "rez", 2.735694704],
+        ],
+        columns=["Id", "Number1", "Number2", "Text1", "Text2", "Number3"],
+    )
+    tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_file_buffer_url.py

@@ -0,0 +1,470 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+from io import (
+    BytesIO,
+    StringIO,
+)
+import os
+import platform
+from urllib.error import URLError
+import uuid
+
+import numpy as np
+import pytest
+
+from pandas.compat import WASM
+from pandas.errors import (
+    EmptyDataError,
+    ParserError,
+)
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    Index,
+)
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
+
+
+@pytest.mark.network
+@pytest.mark.single_cpu
+def test_url(all_parsers, csv_dir_path, httpserver):
+    parser = all_parsers
+    kwargs = {"sep": "\t"}
+
+    local_path = os.path.join(csv_dir_path, "salaries.csv")
+    with open(local_path, encoding="utf-8") as f:
+        httpserver.serve_content(content=f.read())
+
+    url_result = parser.read_csv(httpserver.url, **kwargs)
+
+    local_result = parser.read_csv(local_path, **kwargs)
+    tm.assert_frame_equal(url_result, local_result)
+
+
+@pytest.mark.slow
+def test_local_file(all_parsers, csv_dir_path):
+    parser = all_parsers
+    kwargs = {"sep": "\t"}
+
+    local_path = os.path.join(csv_dir_path, "salaries.csv")
+    local_result = parser.read_csv(local_path, **kwargs)
+    url = "file://localhost/" + local_path
+
+    try:
+        url_result = parser.read_csv(url, **kwargs)
+        tm.assert_frame_equal(url_result, local_result)
+    except URLError:
+        # Fails on some systems.
+        pytest.skip("Failing on: " + " ".join(platform.uname()))
+
+
+@xfail_pyarrow  # AssertionError: DataFrame.index are different
+def test_path_path_lib(all_parsers, temp_file):
+    parser = all_parsers
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD")),
+        index=Index([f"i-{i}" for i in range(30)]),
+    )
+    result = tm.round_trip_pathlib(
+        df.to_csv, lambda p: parser.read_csv(p, index_col=0), temp_file
+    )
+    tm.assert_frame_equal(df, result)
+
+
+@pytest.mark.skipif(WASM, reason="limited file system access on WASM")
+def test_nonexistent_path(all_parsers):
+    # gh-2428: pls no segfault
+    # gh-14086: raise more helpful FileNotFoundError
+    # GH#29233 "File foo" instead of "File b'foo'"
+    parser = all_parsers
+    path = f"{uuid.uuid4()}.csv"
+
+    msg = r"\[Errno 2\]"
+    with pytest.raises(FileNotFoundError, match=msg) as e:
+        parser.read_csv(path)
+    assert path == e.value.filename
+
+
+@pytest.mark.skipif(WASM, reason="limited file system access on WASM")
+@td.skip_if_windows  # os.chmod does not work in windows
+def test_no_permission(all_parsers, temp_file):
+    # GH 23784
+    parser = all_parsers
+
+    msg = r"\[Errno 13\]"
+    path = temp_file
+    os.chmod(path, 0)  # make file unreadable
+
+    # verify that this process cannot open the file (not running as sudo)
+    try:
+        with open(path, encoding="utf-8"):
+            pass
+        pytest.skip("Running as sudo.")
+    except PermissionError:
+        pass
+
+    with pytest.raises(PermissionError, match=msg) as e:
+        parser.read_csv(path)
+    assert str(path.resolve()) == e.value.filename
+
+
+@pytest.mark.parametrize(
+    "data,kwargs,expected,msg",
+    [
+        # gh-10728: WHITESPACE_LINE
+        (
+            "a,b,c\n4,5,6\n ",
+            {},
+            DataFrame([[4, 5, 6]], columns=["a", "b", "c"]),
+            None,
+        ),
+        # gh-10548: EAT_LINE_COMMENT
+        (
+            "a,b,c\n4,5,6\n#comment",
+            {"comment": "#"},
+            DataFrame([[4, 5, 6]], columns=["a", "b", "c"]),
+            None,
+        ),
+        # EAT_CRNL_NOP
+        (
+            "a,b,c\n4,5,6\n\r",
+            {},
+            DataFrame([[4, 5, 6]], columns=["a", "b", "c"]),
+            None,
+        ),
+        # EAT_COMMENT
+        (
+            "a,b,c\n4,5,6#comment",
+            {"comment": "#"},
+            DataFrame([[4, 5, 6]], columns=["a", "b", "c"]),
+            None,
+        ),
+        # SKIP_LINE
+        (
+            "a,b,c\n4,5,6\nskipme",
+            {"skiprows": [2]},
+            DataFrame([[4, 5, 6]], columns=["a", "b", "c"]),
+            None,
+        ),
+        # EAT_LINE_COMMENT
+        (
+            "a,b,c\n4,5,6\n#comment",
+            {"comment": "#", "skip_blank_lines": False},
+            DataFrame([[4, 5, 6]], columns=["a", "b", "c"]),
+            None,
+        ),
+        # IN_FIELD
+        (
+            "a,b,c\n4,5,6\n ",
+            {"skip_blank_lines": False},
+            DataFrame([["4", 5, 6], [" ", None, None]], columns=["a", "b", "c"]),
+            None,
+        ),
+        # EAT_CRNL
+        (
+            "a,b,c\n4,5,6\n\r",
+            {"skip_blank_lines": False},
+            DataFrame([[4, 5, 6], [None, None, None]], columns=["a", "b", "c"]),
+            None,
+        ),
+        # ESCAPED_CHAR
+        (
+            "a,b,c\n4,5,6\n\\",
+            {"escapechar": "\\"},
+            None,
+            "(EOF following escape character)|(unexpected end of data)",
+        ),
+        # ESCAPE_IN_QUOTED_FIELD
+        (
+            'a,b,c\n4,5,6\n"\\',
+            {"escapechar": "\\"},
+            None,
+            "(EOF inside string starting at row 2)|(unexpected end of data)",
+        ),
+        # IN_QUOTED_FIELD
+        (
+            'a,b,c\n4,5,6\n"',
+            {"escapechar": "\\"},
+            None,
+            "(EOF inside string starting at row 2)|(unexpected end of data)",
+        ),
+    ],
+    ids=[
+        "whitespace-line",
+        "eat-line-comment",
+        "eat-crnl-nop",
+        "eat-comment",
+        "skip-line",
+        "eat-line-comment",
+        "in-field",
+        "eat-crnl",
+        "escaped-char",
+        "escape-in-quoted-field",
+        "in-quoted-field",
+    ],
+)
+def test_eof_states(all_parsers, data, kwargs, expected, msg, request):
+    # see gh-10728, gh-10548
+    parser = all_parsers
+
+    if parser.engine == "pyarrow" and "comment" in kwargs:
+        msg = "The 'comment' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), **kwargs)
+        return
+
+    if parser.engine == "pyarrow" and "\r" not in data:
+        # pandas.errors.ParserError: CSV parse error: Expected 3 columns, got 1:
+        # ValueError: skiprows argument must be an integer when using engine='pyarrow'
+        # AssertionError: Regex pattern did not match.
+        pytest.skip(reason="https://github.com/apache/arrow/issues/38676")
+
+    if expected is None:
+        with pytest.raises(ParserError, match=msg):
+            parser.read_csv(StringIO(data), **kwargs)
+    else:
+        result = parser.read_csv(StringIO(data), **kwargs)
+        tm.assert_frame_equal(result, expected)
+
+
+def test_temporary_file(all_parsers, temp_file):
+    # see gh-13398
+    parser = all_parsers
+    data = "0 0"
+
+    with temp_file.open(mode="w+", encoding="utf-8") as new_file:
+        new_file.write(data)
+        new_file.flush()
+        new_file.seek(0)
+
+        if parser.engine == "pyarrow":
+            msg = "the 'pyarrow' engine does not support regex separators"
+            with pytest.raises(ValueError, match=msg):
+                parser.read_csv(new_file, sep=r"\s+", header=None)
+            return
+
+        result = parser.read_csv(new_file, sep=r"\s+", header=None)
+
+        expected = DataFrame([[0, 0]])
+        tm.assert_frame_equal(result, expected)
+
+
+def test_internal_eof_byte(all_parsers):
+    # see gh-5500
+    parser = all_parsers
+    data = "a,b\n1\x1a,2"
+
+    expected = DataFrame([["1\x1a", 2]], columns=["a", "b"])
+    result = parser.read_csv(StringIO(data))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_internal_eof_byte_to_file(all_parsers, temp_file):
+    # see gh-16559
+    parser = all_parsers
+    data = b'c1,c2\r\n"test \x1a    test", test\r\n'
+    expected = DataFrame([["test \x1a    test", " test"]], columns=["c1", "c2"])
+    path = f"__{uuid.uuid4()}__.csv"
+
+    path2 = temp_file.parent / path
+    with open(path2, "wb") as f:
+        f.write(data)
+
+    result = parser.read_csv(path2)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_file_handle_string_io(all_parsers):
+    # gh-14418
+    #
+    # Don't close user provided file handles.
+    parser = all_parsers
+    data = "a,b\n1,2"
+
+    fh = StringIO(data)
+    parser.read_csv(fh)
+    assert not fh.closed
+
+
+def test_file_handles_with_open(all_parsers, csv1):
+    # gh-14418
+    #
+    # Don't close user provided file handles.
+    parser = all_parsers
+
+    for mode in ["r", "rb"]:
+        with open(csv1, mode, encoding="utf-8" if mode == "r" else None) as f:
+            parser.read_csv(f)
+            assert not f.closed
+
+
+def test_invalid_file_buffer_class(all_parsers):
+    # see gh-15337
+    class InvalidBuffer:
+        pass
+
+    parser = all_parsers
+    msg = "Invalid file path or buffer object type"
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(InvalidBuffer())
+
+
+def test_invalid_file_buffer_mock(all_parsers):
+    # see gh-15337
+    parser = all_parsers
+    msg = "Invalid file path or buffer object type"
+
+    class Foo:
+        pass
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(Foo())
+
+
+def test_valid_file_buffer_seems_invalid(all_parsers):
+    # gh-16135: we want to ensure that "tell" and "seek"
+    # aren't actually being used when we call `read_csv`
+    #
+    # Thus, while the object may look "invalid" (these
+    # methods are attributes of the `StringIO` class),
+    # it is still a valid file-object for our purposes.
+    class NoSeekTellBuffer(StringIO):
+        def tell(self):
+            raise AttributeError("No tell method")
+
+        def seek(self, pos, whence=0):
+            raise AttributeError("No seek method")
+
+    data = "a\n1"
+    parser = all_parsers
+    expected = DataFrame({"a": [1]})
+
+    result = parser.read_csv(NoSeekTellBuffer(data))
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("io_class", [StringIO, BytesIO])
+@pytest.mark.parametrize("encoding", [None, "utf-8"])
+def test_read_csv_file_handle(all_parsers, io_class, encoding):
+    """
+    Test whether read_csv does not close user-provided file handles.
+
+    GH 36980
+    """
+    parser = all_parsers
+    expected = DataFrame({"a": [1], "b": [2]})
+
+    content = "a,b\n1,2"
+    handle = io_class(content.encode("utf-8") if io_class == BytesIO else content)
+
+    tm.assert_frame_equal(parser.read_csv(handle, encoding=encoding), expected)
+    assert not handle.closed
+
+
+def test_memory_map_compression(all_parsers, compression, temp_file):
+    """
+    Support memory map for compressed files.
+
+    GH 37621
+    """
+    parser = all_parsers
+    expected = DataFrame({"a": [1], "b": [2]})
+
+    path = temp_file
+    expected.to_csv(path, index=False, compression=compression)
+
+    if parser.engine == "pyarrow":
+        msg = "The 'memory_map' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(path, memory_map=True, compression=compression)
+        return
+
+    result = parser.read_csv(path, memory_map=True, compression=compression)
+
+    tm.assert_frame_equal(
+        result,
+        expected,
+    )
+
+
+def test_context_manager(all_parsers, datapath):
+    # make sure that opened files are closed
+    parser = all_parsers
+
+    path = datapath("io", "data", "csv", "iris.csv")
+
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(path, chunksize=1)
+        return
+
+    reader = parser.read_csv(path, chunksize=1)
+    assert not reader.handles.handle.closed
+    try:
+        with reader:
+            next(reader)
+            raise AssertionError
+    except AssertionError:
+        assert reader.handles.handle.closed
+
+
+def test_context_manageri_user_provided(all_parsers, datapath):
+    # make sure that user-provided handles are not closed
+    parser = all_parsers
+
+    with open(datapath("io", "data", "csv", "iris.csv"), encoding="utf-8") as path:
+        if parser.engine == "pyarrow":
+            msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+            with pytest.raises(ValueError, match=msg):
+                parser.read_csv(path, chunksize=1)
+            return
+
+        reader = parser.read_csv(path, chunksize=1)
+        assert not reader.handles.handle.closed
+        try:
+            with reader:
+                next(reader)
+                raise AssertionError
+        except AssertionError:
+            assert not reader.handles.handle.closed
+
+
+@skip_pyarrow  # ParserError: Empty CSV file
+def test_file_descriptor_leak(all_parsers, temp_file):
+    # GH 31488
+    parser = all_parsers
+    path = temp_file
+    with pytest.raises(EmptyDataError, match="No columns to parse from file"):
+        parser.read_csv(path)
+
+
+def test_memory_map(all_parsers, csv_dir_path):
+    mmap_file = os.path.join(csv_dir_path, "test_mmap.csv")
+    parser = all_parsers
+
+    expected = DataFrame(
+        {"a": [1, 2, 3], "b": ["one", "two", "three"], "c": ["I", "II", "III"]}
+    )
+
+    if parser.engine == "pyarrow":
+        msg = "The 'memory_map' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(mmap_file, memory_map=True)
+        return
+
+    result = parser.read_csv(mmap_file, memory_map=True)
+    tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_float.py

@@ -0,0 +1,110 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+from io import StringIO
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
+
+
+@skip_pyarrow  # ParserError: CSV parse error: Empty CSV file or block
+def test_float_parser(all_parsers):
+    # see gh-9565
+    parser = all_parsers
+    data = "45e-1,4.5,45.,inf,-inf"
+    result = parser.read_csv(StringIO(data), header=None)
+
+    expected = DataFrame([[float(s) for s in data.split(",")]])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_scientific_no_exponent(all_parsers_all_precisions):
+    # see gh-12215
+    df = DataFrame.from_dict({"w": ["2e"], "x": ["3E"], "y": ["42e"], "z": ["632E"]})
+    data = df.to_csv(index=False)
+    parser, precision = all_parsers_all_precisions
+
+    df_roundtrip = parser.read_csv(StringIO(data), float_precision=precision)
+    tm.assert_frame_equal(df_roundtrip, df)
+
+
+@pytest.mark.parametrize(
+    "value, expected_value",
+    [
+        ("0E-617", 0.0),
+        ("0E99999999", 0.0),
+        ("-0E99999999", 0.0),
+        ("-0E-99999999", 0.0),
+        ("10E-617", 0.0),
+        ("10E-100000", 0.0),
+        ("-10E-100000", 0.0),
+        ("10e-99999999999", 0.0),
+        ("10e-999999999999", 0.0),
+        ("10e-9999999999999", 0.0),
+        ("10E999", np.inf),
+        ("-10e99999999999", -np.inf),
+        ("10e99999999999", np.inf),
+        ("10e999999999999", np.inf),
+        ("10e9999999999999", np.inf),
+        ("50060e8007123400", np.inf),
+        ("-50060e8007123400", -np.inf),
+    ],
+)
+def test_large_exponent(all_parsers_all_precisions, value, expected_value):
+    # GH#38753; GH#38794; GH#62740
+    parser, precision = all_parsers_all_precisions
+
+    data = f"data\n{value}"
+    result = parser.read_csv(StringIO(data), float_precision=precision)
+    expected = DataFrame({"data": [expected_value]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "value, expected_value",
+    [
+        ("32.0", 32.0),
+        ("32e0", 32.0),
+        ("3.2e1", 32.0),
+        ("3.2e80", 3.2e80),
+        ("3.2e-80", 3.2e-80),
+        ("18446744073709551616.0", float(1 << 64)),  # loses precision
+        ("18446744073709551616.5", float(1 << 64)),  # loses precision
+        ("36893488147419103232.3", float(1 << 65)),  # loses precision
+    ],
+)
+def test_small_int_followed_by_float(
+    all_parsers_all_precisions, value, expected_value, request
+):
+    # GH#51295
+    parser, precision = all_parsers_all_precisions
+    data = f"""data
+    42
+    {value}"""
+    result = parser.read_csv(StringIO(data), float_precision=precision)
+    expected = DataFrame({"data": [42.0, expected_value]})
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "value", ["81e31d04049863b72", "d81e31d04049863b72", "81e3104049863b72"]
+)
+def test_invalid_float_number(all_parsers_all_precisions, value):
+    # GH#62617
+    parser, precision = all_parsers_all_precisions
+    data = f"h1,h2,h3\ndata1,{value},data3"
+
+    result = parser.read_csv(StringIO(data), float_precision=precision)
+    expected = DataFrame({"h1": ["data1"], "h2": [value], "h3": "data3"})
+    tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_index.py

@@ -0,0 +1,307 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+from datetime import datetime
+from io import StringIO
+import os
+
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+)
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
+
+
+@pytest.mark.parametrize(
+    "data,kwargs,expected",
+    [
+        (
+            """foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+""",
+            {"index_col": 0, "names": ["index", "A", "B", "C", "D"]},
+            DataFrame(
+                [
+                    [2, 3, 4, 5],
+                    [7, 8, 9, 10],
+                    [12, 13, 14, 15],
+                    [12, 13, 14, 15],
+                    [12, 13, 14, 15],
+                    [12, 13, 14, 15],
+                ],
+                index=Index(["foo", "bar", "baz", "qux", "foo2", "bar2"], name="index"),
+                columns=["A", "B", "C", "D"],
+            ),
+        ),
+        (
+            """foo,one,2,3,4,5
+foo,two,7,8,9,10
+foo,three,12,13,14,15
+bar,one,12,13,14,15
+bar,two,12,13,14,15
+""",
+            {"index_col": [0, 1], "names": ["index1", "index2", "A", "B", "C", "D"]},
+            DataFrame(
+                [
+                    [2, 3, 4, 5],
+                    [7, 8, 9, 10],
+                    [12, 13, 14, 15],
+                    [12, 13, 14, 15],
+                    [12, 13, 14, 15],
+                ],
+                index=MultiIndex.from_tuples(
+                    [
+                        ("foo", "one"),
+                        ("foo", "two"),
+                        ("foo", "three"),
+                        ("bar", "one"),
+                        ("bar", "two"),
+                    ],
+                    names=["index1", "index2"],
+                ),
+                columns=["A", "B", "C", "D"],
+            ),
+        ),
+    ],
+)
+def test_pass_names_with_index(all_parsers, data, kwargs, expected):
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("index_col", [[0, 1], [1, 0]])
+def test_multi_index_no_level_names(
+    request, all_parsers, index_col, using_infer_string
+):
+    data = """index1,index2,A,B,C,D
+foo,one,2,3,4,5
+foo,two,7,8,9,10
+foo,three,12,13,14,15
+bar,one,12,13,14,15
+bar,two,12,13,14,15
+"""
+    headless_data = "\n".join(data.split("\n")[1:])
+
+    names = ["A", "B", "C", "D"]
+    parser = all_parsers
+
+    result = parser.read_csv(
+        StringIO(headless_data), index_col=index_col, header=None, names=names
+    )
+    expected = parser.read_csv(StringIO(data), index_col=index_col)
+
+    # No index names in headless data.
+    expected.index.names = [None] * 2
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_multi_index_no_level_names_implicit(all_parsers):
+    parser = all_parsers
+    data = """A,B,C,D
+foo,one,2,3,4,5
+foo,two,7,8,9,10
+foo,three,12,13,14,15
+bar,one,12,13,14,15
+bar,two,12,13,14,15
+"""
+
+    result = parser.read_csv(StringIO(data))
+    expected = DataFrame(
+        [
+            [2, 3, 4, 5],
+            [7, 8, 9, 10],
+            [12, 13, 14, 15],
+            [12, 13, 14, 15],
+            [12, 13, 14, 15],
+        ],
+        columns=["A", "B", "C", "D"],
+        index=MultiIndex.from_tuples(
+            [
+                ("foo", "one"),
+                ("foo", "two"),
+                ("foo", "three"),
+                ("bar", "one"),
+                ("bar", "two"),
+            ]
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow  # TypeError: an integer is required
+@pytest.mark.parametrize(
+    "data,columns,header",
+    [
+        ("a,b", ["a", "b"], [0]),
+        (
+            "a,b\nc,d",
+            MultiIndex.from_tuples([("a", "c"), ("b", "d")]),
+            [0, 1],
+        ),
+    ],
+)
+@pytest.mark.parametrize("round_trip", [True, False])
+def test_multi_index_blank_df(all_parsers, data, columns, header, round_trip):
+    # see gh-14545
+    parser = all_parsers
+    expected = DataFrame(columns=columns)
+    data = expected.to_csv(index=False) if round_trip else data
+
+    result = parser.read_csv(StringIO(data), header=header)
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow  # AssertionError: DataFrame.columns are different
+def test_no_unnamed_index(all_parsers):
+    parser = all_parsers
+    data = """ id c0 c1 c2
+0 1 0 a b
+1 2 0 c d
+2 2 2 e f
+"""
+    result = parser.read_csv(StringIO(data), sep=" ")
+    expected = DataFrame(
+        [[0, 1, 0, "a", "b"], [1, 2, 0, "c", "d"], [2, 2, 2, "e", "f"]],
+        columns=["Unnamed: 0", "id", "c0", "c1", "c2"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_duplicate_index_explicit(all_parsers):
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo,12,13,14,15
+bar,12,13,14,15
+"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), index_col=0)
+
+    expected = DataFrame(
+        [
+            [2, 3, 4, 5],
+            [7, 8, 9, 10],
+            [12, 13, 14, 15],
+            [12, 13, 14, 15],
+            [12, 13, 14, 15],
+            [12, 13, 14, 15],
+        ],
+        columns=["A", "B", "C", "D"],
+        index=Index(["foo", "bar", "baz", "qux", "foo", "bar"], name="index"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_read_duplicate_index_implicit(all_parsers):
+    data = """A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo,12,13,14,15
+bar,12,13,14,15
+"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data))
+
+    expected = DataFrame(
+        [
+            [2, 3, 4, 5],
+            [7, 8, 9, 10],
+            [12, 13, 14, 15],
+            [12, 13, 14, 15],
+            [12, 13, 14, 15],
+            [12, 13, 14, 15],
+        ],
+        columns=["A", "B", "C", "D"],
+        index=Index(["foo", "bar", "baz", "qux", "foo", "bar"]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_read_csv_no_index_name(all_parsers, csv_dir_path):
+    parser = all_parsers
+    csv2 = os.path.join(csv_dir_path, "test2.csv")
+    result = parser.read_csv(csv2, index_col=0, parse_dates=True)
+
+    expected = DataFrame(
+        [
+            [0.980269, 3.685731, -0.364216805298, -1.159738, "foo"],
+            [1.047916, -0.041232, -0.16181208307, 0.212549, "bar"],
+            [0.498581, 0.731168, -0.537677223318, 1.346270, "baz"],
+            [1.120202, 1.567621, 0.00364077397681, 0.675253, "qux"],
+            [-0.487094, 0.571455, -1.6116394093, 0.103469, "foo2"],
+        ],
+        columns=["A", "B", "C", "D", "E"],
+        index=Index(
+            [
+                datetime(2000, 1, 3),
+                datetime(2000, 1, 4),
+                datetime(2000, 1, 5),
+                datetime(2000, 1, 6),
+                datetime(2000, 1, 7),
+            ],
+            dtype="M8[us]",
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+def test_empty_with_index(all_parsers):
+    # see gh-10184
+    data = "x,y"
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), index_col=0)
+
+    expected = DataFrame(columns=["y"], index=Index([], name="x"))
+    tm.assert_frame_equal(result, expected)
+
+
+# CSV parse error: Empty CSV file or block: cannot infer number of columns
+@skip_pyarrow
+def test_empty_with_multi_index(all_parsers):
+    # see gh-10467
+    data = "x,y,z"
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), index_col=["x", "y"])
+
+    expected = DataFrame(
+        columns=["z"], index=MultiIndex.from_arrays([[]] * 2, names=["x", "y"])
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+# CSV parse error: Empty CSV file or block: cannot infer number of columns
+@skip_pyarrow
+def test_empty_with_reversed_multi_index(all_parsers):
+    data = "x,y,z"
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), index_col=[1, 0])
+
+    expected = DataFrame(
+        columns=["z"], index=MultiIndex.from_arrays([[]] * 2, names=["y", "x"])
+    )
+    tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_inf.py

@@ -0,0 +1,59 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+from io import StringIO
+
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+
+
+@xfail_pyarrow  # AssertionError: DataFrame.index are different
+@pytest.mark.parametrize("na_filter", [True, False])
+def test_inf_parsing(all_parsers, na_filter):
+    parser = all_parsers
+    data = """\
+,A
+a,inf
+b,-inf
+c,+Inf
+d,-Inf
+e,INF
+f,-INF
+g,+INf
+h,-INf
+i,inF
+j,-inF"""
+    expected = DataFrame(
+        {"A": [float("inf"), float("-inf")] * 5},
+        index=["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"],
+    )
+    result = parser.read_csv(StringIO(data), index_col=0, na_filter=na_filter)
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow  # AssertionError: DataFrame.index are different
+@pytest.mark.parametrize("na_filter", [True, False])
+def test_infinity_parsing(all_parsers, na_filter):
+    parser = all_parsers
+    data = """\
+,A
+a,Infinity
+b,-Infinity
+c,+Infinity
+"""
+    expected = DataFrame(
+        {"A": [float("infinity"), float("-infinity"), float("+infinity")]},
+        index=["a", "b", "c"],
+    )
+    result = parser.read_csv(StringIO(data), index_col=0, na_filter=na_filter)
+    tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_ints.py

@@ -0,0 +1,244 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+from io import StringIO
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
+
+
+def test_int_conversion(all_parsers):
+    data = """A,B
+1.0,1
+2.0,2
+3.0,3
+"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data))
+
+    expected = DataFrame([[1.0, 1], [2.0, 2], [3.0, 3]], columns=["A", "B"])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data,kwargs,expected",
+    [
+        (
+            "A,B\nTrue,1\nFalse,2\nTrue,3",
+            {},
+            [[True, 1], [False, 2], [True, 3]],
+        ),
+        (
+            "A,B\nYES,1\nno,2\nyes,3\nNo,3\nYes,3",
+            {"true_values": ["yes", "Yes", "YES"], "false_values": ["no", "NO", "No"]},
+            [[True, 1], [False, 2], [True, 3], [False, 3], [True, 3]],
+        ),
+        (
+            "A,B\nTRUE,1\nFALSE,2\nTRUE,3",
+            {},
+            [[True, 1], [False, 2], [True, 3]],
+        ),
+        (
+            "A,B\nfoo,bar\nbar,foo",
+            {"true_values": ["foo"], "false_values": ["bar"]},
+            [[True, False], [False, True]],
+        ),
+    ],
+)
+def test_parse_bool(all_parsers, data, kwargs, expected):
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), **kwargs)
+    expected = DataFrame(expected, columns=["A", "B"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_parse_integers_above_fp_precision(all_parsers):
+    data = """Numbers
+17007000002000191
+17007000002000191
+17007000002000191
+17007000002000191
+17007000002000192
+17007000002000192
+17007000002000192
+17007000002000192
+17007000002000192
+17007000002000194"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data))
+    expected = DataFrame(
+        {
+            "Numbers": [
+                17007000002000191,
+                17007000002000191,
+                17007000002000191,
+                17007000002000191,
+                17007000002000192,
+                17007000002000192,
+                17007000002000192,
+                17007000002000192,
+                17007000002000192,
+                17007000002000194,
+            ]
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("sep", [" ", r"\s+"])
+def test_integer_overflow_bug(all_parsers, sep):
+    # see gh-2601
+    data = "65248E10 11\n55555E55 22\n"
+    parser = all_parsers
+    if parser.engine == "pyarrow" and sep != " ":
+        msg = "the 'pyarrow' engine does not support regex separators"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), header=None, sep=sep)
+        return
+
+    result = parser.read_csv(StringIO(data), header=None, sep=sep)
+    expected = DataFrame([[6.5248e14, 11], [5.5555e59, 22]])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_int64_min_issues(all_parsers):
+    # see gh-2599
+    parser = all_parsers
+    data = "A,B\n0,0\n0,"
+    result = parser.read_csv(StringIO(data))
+
+    expected = DataFrame({"A": [0, 0], "B": [0, np.nan]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("conv", [None, np.int64, np.uint64])
+def test_int64_overflow(all_parsers, conv, request):
+    data = """ID
+00013007854817840016671868
+00013007854817840016749251
+00013007854817840016754630
+00013007854817840016781876
+00013007854817840017028824
+00013007854817840017963235
+00013007854817840018860166"""
+    parser = all_parsers
+
+    if conv is None:
+        # 13007854817840016671868 > UINT64_MAX, so this
+        # will overflow and return object as the dtype.
+        if parser.engine == "pyarrow":
+            mark = pytest.mark.xfail(reason="parses to float64")
+            request.applymarker(mark)
+
+        result = parser.read_csv(StringIO(data))
+        expected = DataFrame(
+            [
+                13007854817840016671868,
+                13007854817840016749251,
+                13007854817840016754630,
+                13007854817840016781876,
+                13007854817840017028824,
+                13007854817840017963235,
+                13007854817840018860166,
+            ],
+            columns=["ID"],
+        )
+        tm.assert_frame_equal(result, expected)
+    else:
+        # 13007854817840016671868 > UINT64_MAX, so attempts
+        # to cast to either int64 or uint64 will result in
+        # an OverflowError being raised.
+        msg = "|".join(
+            [
+                "Python int too large to convert to C long",
+                "long too big to convert",
+                "int too big to convert",
+            ]
+        )
+        err = OverflowError
+        if parser.engine == "pyarrow":
+            err = ValueError
+            msg = "The 'converters' option is not supported with the 'pyarrow' engine"
+
+        with pytest.raises(err, match=msg):
+            parser.read_csv(StringIO(data), converters={"ID": conv})
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+@pytest.mark.parametrize(
+    "val", [np.iinfo(np.uint64).max, np.iinfo(np.int64).max, np.iinfo(np.int64).min]
+)
+def test_int64_uint64_range(all_parsers, val):
+    # These numbers fall right inside the int64-uint64
+    # range, so they should be parsed as integer.
+    parser = all_parsers
+    result = parser.read_csv(StringIO(str(val)), header=None)
+
+    expected = DataFrame([val])
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+@pytest.mark.parametrize(
+    "val", [np.iinfo(np.uint64).max + 1, np.iinfo(np.int64).min - 1]
+)
+def test_outside_int64_uint64_range(all_parsers, val, request):
+    # These numbers fall just outside the int64-uint64
+    # range, so they should be parsed as object.
+    parser = all_parsers
+
+    result = parser.read_csv(StringIO(str(val)), header=None)
+
+    expected = DataFrame([val])
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+@pytest.mark.parametrize(
+    "val", [np.iinfo(np.uint64).max + 1, np.iinfo(np.int64).min - 1]
+)
+def test_outside_int64_uint64_range_follow_str(all_parsers, val):
+    parser = all_parsers
+
+    result = parser.read_csv(StringIO(f"{val}\nabc"), header=None)
+
+    expected = DataFrame([str(val), "abc"])
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow  # gets float64 dtype instead of object
+@pytest.mark.parametrize("exp_data", [[str(-1), str(2**63)], [str(2**63), str(-1)]])
+def test_numeric_range_too_wide(all_parsers, exp_data):
+    # No numerical dtype can hold both negative and uint64
+    # values, so they should be cast as string.
+    parser = all_parsers
+    data = "\n".join(exp_data)
+    expected = DataFrame(exp_data)
+
+    result = parser.read_csv(StringIO(data), header=None)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_integer_precision(all_parsers):
+    # Gh 7072
+    s = """1,1;0;0;0;1;1;3844;3844;3844;1;1;1;1;1;1;0;0;1;1;0;0,,,4321583677327450765
+5,1;0;0;0;1;1;843;843;843;1;1;1;1;1;1;0;0;1;1;0;0,64.0,;,4321113141090630389"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(s), header=None)[4]
+    expected = Series([4321583677327450765, 4321113141090630389], name=4)
+    tm.assert_series_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_iterator.py

@@ -0,0 +1,159 @@
+"""
+Tests that work on both the Python and C engines but do not have a
+specific classification into the other test modules.
+"""
+
+from io import StringIO
+
+import pytest
+
+from pandas import (
+    DataFrame,
+    concat,
+)
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+def test_iterator(all_parsers):
+    # see gh-6607
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+    parser = all_parsers
+    kwargs = {"index_col": 0}
+
+    expected = parser.read_csv(StringIO(data), **kwargs)
+
+    if parser.engine == "pyarrow":
+        msg = "The 'iterator' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), iterator=True, **kwargs)
+        return
+
+    with parser.read_csv(StringIO(data), iterator=True, **kwargs) as reader:
+        first_chunk = reader.read(3)
+        tm.assert_frame_equal(first_chunk, expected[:3])
+
+        last_chunk = reader.read(5)
+    tm.assert_frame_equal(last_chunk, expected[3:])
+
+
+def test_iterator2(all_parsers):
+    parser = all_parsers
+    data = """A,B,C
+foo,1,2,3
+bar,4,5,6
+baz,7,8,9
+"""
+
+    if parser.engine == "pyarrow":
+        msg = "The 'iterator' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), iterator=True)
+        return
+
+    with parser.read_csv(StringIO(data), iterator=True) as reader:
+        result = list(reader)
+
+    expected = DataFrame(
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+        index=["foo", "bar", "baz"],
+        columns=["A", "B", "C"],
+    )
+    tm.assert_frame_equal(result[0], expected)
+
+
+def test_iterator_stop_on_chunksize(all_parsers):
+    # gh-3967: stopping iteration when chunksize is specified
+    parser = all_parsers
+    data = """A,B,C
+foo,1,2,3
+bar,4,5,6
+baz,7,8,9
+"""
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), chunksize=1)
+        return
+
+    with parser.read_csv(StringIO(data), chunksize=1) as reader:
+        result = list(reader)
+
+    assert len(result) == 3
+    expected = DataFrame(
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+        index=["foo", "bar", "baz"],
+        columns=["A", "B", "C"],
+    )
+    tm.assert_frame_equal(concat(result), expected)
+
+
+def test_nrows_iterator_without_chunksize(all_parsers):
+    # GH 59079
+    parser = all_parsers
+    data = """A,B,C
+foo,1,2,3
+bar,4,5,6
+baz,7,8,9
+"""
+    if parser.engine == "pyarrow":
+        msg = "The 'iterator' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), iterator=True, nrows=2)
+        return
+
+    with parser.read_csv(StringIO(data), iterator=True, nrows=2) as reader:
+        result = reader.get_chunk()
+
+    expected = DataFrame(
+        [[1, 2, 3], [4, 5, 6]],
+        index=["foo", "bar"],
+        columns=["A", "B", "C"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "kwargs", [{"iterator": True, "chunksize": 1}, {"iterator": True}, {"chunksize": 1}]
+)
+def test_iterator_skipfooter_errors(all_parsers, kwargs):
+    msg = "'skipfooter' not supported for iteration"
+    parser = all_parsers
+    data = "a\n1\n2"
+
+    if parser.engine == "pyarrow":
+        msg = (
+            "The '(chunksize|iterator)' option is not supported with the "
+            "'pyarrow' engine"
+        )
+
+    with pytest.raises(ValueError, match=msg):
+        with parser.read_csv(StringIO(data), skipfooter=1, **kwargs) as _:
+            pass
+
+
+def test_iteration_open_handle(temp_file, all_parsers):
+    parser = all_parsers
+    kwargs = {"header": None}
+
+    with open(temp_file, "w", encoding="utf-8") as f:
+        f.write("AAA\nBBB\nCCC\nDDD\nEEE\nFFF\nGGG")
+
+    with open(temp_file, encoding="utf-8") as f:
+        for line in f:
+            if "CCC" in line:
+                break
+
+        result = parser.read_csv(f, **kwargs)
+        expected = DataFrame({0: ["DDD", "EEE", "FFF", "GGG"]})
+        tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/common/test_read_errors.py

@@ -0,0 +1,315 @@
+"""
+Tests that work on the Python, C and PyArrow engines but do not have a
+specific classification into the other test modules.
+"""
+
+import codecs
+import csv
+from io import StringIO
+import os
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from pandas.errors import (
+    EmptyDataError,
+    ParserError,
+    ParserWarning,
+)
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
+
+
+def test_empty_decimal_marker(all_parsers):
+    data = """A|B|C
+1|2,334|5
+10|13|10.
+"""
+    # Parsers support only length-1 decimals
+    msg = "Only length-1 decimal markers supported"
+    parser = all_parsers
+
+    if parser.engine == "pyarrow":
+        msg = (
+            "only single character unicode strings can be "
+            "converted to Py_UCS4, got length 0"
+        )
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(StringIO(data), decimal="")
+
+
+def test_bad_stream_exception(all_parsers, csv_dir_path):
+    # see gh-13652
+    #
+    # This test validates that both the Python engine and C engine will
+    # raise UnicodeDecodeError instead of C engine raising ParserError
+    # and swallowing the exception that caused read to fail.
+    path = os.path.join(csv_dir_path, "sauron.SHIFT_JIS.csv")
+    codec = codecs.lookup("utf-8")
+    utf8 = codecs.lookup("utf-8")
+    parser = all_parsers
+    msg = "'utf-8' codec can't decode byte"
+
+    # Stream must be binary UTF8.
+    with (
+        open(path, "rb") as handle,
+        codecs.StreamRecoder(
+            handle, utf8.encode, utf8.decode, codec.streamreader, codec.streamwriter
+        ) as stream,
+    ):
+        with pytest.raises(UnicodeDecodeError, match=msg):
+            parser.read_csv(stream)
+
+
+def test_malformed(all_parsers):
+    # see gh-6607
+    parser = all_parsers
+    data = """ignore
+A,B,C
+1,2,3 # comment
+1,2,3,4,5
+2,3,4
+"""
+    msg = "Expected 3 fields in line 4, saw 5"
+    err = ParserError
+    if parser.engine == "pyarrow":
+        msg = "The 'comment' option is not supported with the 'pyarrow' engine"
+        err = ValueError
+    with pytest.raises(err, match=msg):
+        parser.read_csv(StringIO(data), header=1, comment="#")
+
+
+@pytest.mark.parametrize("nrows", [5, 3, None])
+def test_malformed_chunks(all_parsers, nrows):
+    data = """ignore
+A,B,C
+skip
+1,2,3
+3,5,10 # comment
+1,2,3,4,5
+2,3,4
+"""
+    parser = all_parsers
+
+    if parser.engine == "pyarrow":
+        msg = "The 'iterator' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(
+                StringIO(data),
+                header=1,
+                comment="#",
+                iterator=True,
+                chunksize=1,
+                skiprows=[2],
+            )
+        return
+
+    msg = "Expected 3 fields in line 6, saw 5"
+    with parser.read_csv(
+        StringIO(data), header=1, comment="#", iterator=True, chunksize=1, skiprows=[2]
+    ) as reader:
+        with pytest.raises(ParserError, match=msg):
+            reader.read(nrows)
+
+
+@xfail_pyarrow  # does not raise
+def test_catch_too_many_names(all_parsers):
+    # see gh-5156
+    data = """\
+1,2,3
+4,,6
+7,8,9
+10,11,12\n"""
+    parser = all_parsers
+    msg = (
+        "Too many columns specified: expected 4 and found 3"
+        if parser.engine == "c"
+        else "Number of passed names did not match number of header fields in the file"
+    )
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(StringIO(data), header=0, names=["a", "b", "c", "d"])
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+@pytest.mark.parametrize("nrows", [0, 1, 2, 3, 4, 5])
+def test_raise_on_no_columns(all_parsers, nrows):
+    parser = all_parsers
+    data = "\n" * nrows
+
+    msg = "No columns to parse from file"
+    with pytest.raises(EmptyDataError, match=msg):
+        parser.read_csv(StringIO(data))
+
+
+def test_unexpected_keyword_parameter_exception(all_parsers):
+    # GH-34976
+    parser = all_parsers
+
+    msg = "{}\\(\\) got an unexpected keyword argument 'foo'"
+    with pytest.raises(TypeError, match=msg.format("read_csv")):
+        parser.read_csv("foo.csv", foo=1)
+    with pytest.raises(TypeError, match=msg.format("read_table")):
+        parser.read_table("foo.tsv", foo=1)
+
+
+def test_suppress_error_output(all_parsers):
+    # see gh-15925
+    parser = all_parsers
+    data = "a\n1\n1,2,3\n4\n5,6,7"
+    expected = DataFrame({"a": [1, 4]})
+
+    result = parser.read_csv(StringIO(data), on_bad_lines="skip")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_error_bad_lines(all_parsers):
+    # see gh-15925
+    parser = all_parsers
+    data = "a\n1\n1,2,3\n4\n5,6,7"
+
+    msg = "Expected 1 fields in line 3, saw 3"
+
+    if parser.engine == "pyarrow":
+        # "CSV parse error: Expected 1 columns, got 3: 1,2,3"
+        pytest.skip(reason="https://github.com/apache/arrow/issues/38676")
+
+    with pytest.raises(ParserError, match=msg):
+        parser.read_csv(StringIO(data), on_bad_lines="error")
+
+
+def test_warn_bad_lines(all_parsers):
+    # see gh-15925
+    parser = all_parsers
+    data = "a\n1\n1,2,3\n4\n5,6,7"
+    expected = DataFrame({"a": [1, 4]})
+    match_msg = "Skipping line"
+
+    expected_warning = ParserWarning
+    if parser.engine == "pyarrow":
+        match_msg = "Expected 1 columns, but found 3: 1,2,3"
+
+    with tm.assert_produces_warning(
+        expected_warning, match=match_msg, check_stacklevel=False
+    ):
+        result = parser.read_csv(StringIO(data), on_bad_lines="warn")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_csv_wrong_num_columns(all_parsers):
+    # Too few columns.
+    data = """A,B,C,D,E,F
+1,2,3,4,5,6
+6,7,8,9,10,11,12
+11,12,13,14,15,16
+"""
+    parser = all_parsers
+    msg = "Expected 6 fields in line 3, saw 7"
+
+    if parser.engine == "pyarrow":
+        # Expected 6 columns, got 7: 6,7,8,9,10,11,12
+        pytest.skip(reason="https://github.com/apache/arrow/issues/38676")
+
+    with pytest.raises(ParserError, match=msg):
+        parser.read_csv(StringIO(data))
+
+
+def test_null_byte_char(request, all_parsers):
+    # see gh-2741
+    data = "\x00,foo"
+    names = ["a", "b"]
+    parser = all_parsers
+
+    if parser.engine in ["c", "python"]:
+        if parser.engine == "python":
+            request.applymarker(
+                pytest.mark.xfail(reason="This is read as an empty character not null")
+            )
+        expected = DataFrame([[np.nan, "foo"]], columns=names)
+        out = parser.read_csv(StringIO(data), names=names)
+        tm.assert_frame_equal(out, expected)
+    else:
+        if parser.engine == "pyarrow":
+            # CSV parse error: Empty CSV file or block: "
+            # cannot infer number of columns"
+            pytest.skip(reason="https://github.com/apache/arrow/issues/38676")
+        else:
+            msg = "NULL byte detected"
+        with pytest.raises(ParserError, match=msg):
+            parser.read_csv(StringIO(data), names=names)
+
+
+@pytest.mark.filterwarnings("always::ResourceWarning")
+def test_open_file(all_parsers, temp_file):
+    # GH 39024
+    parser = all_parsers
+
+    msg = "Could not determine delimiter"
+    err = csv.Error
+    if parser.engine == "c":
+        msg = "object of type 'NoneType' has no len"
+        err = TypeError
+    elif parser.engine == "pyarrow":
+        msg = "'utf-8' codec can't decode byte 0xe4"
+        err = ValueError
+
+    file = Path(temp_file)
+    file.write_bytes(b"\xe4\na\n1")
+
+    with tm.assert_produces_warning(None):
+        # should not trigger a ResourceWarning
+        with pytest.raises(err, match=msg):
+            parser.read_csv(file, sep=None, encoding_errors="replace")
+
+
+def test_invalid_on_bad_line(all_parsers):
+    parser = all_parsers
+    data = "a\n1\n1,2,3\n4\n5,6,7"
+    with pytest.raises(ValueError, match="Argument abc is invalid for on_bad_lines"):
+        parser.read_csv(StringIO(data), on_bad_lines="abc")
+
+
+def test_bad_header_uniform_error(all_parsers):
+    parser = all_parsers
+    data = "+++123456789...\ncol1,col2,col3,col4\n1,2,3,4\n"
+    msg = "Expected 2 fields in line 2, saw 4"
+    if parser.engine == "c":
+        msg = (
+            "Could not construct index. Requested to use 1 "
+            "number of columns, but 3 left to parse."
+        )
+    elif parser.engine == "pyarrow":
+        # "CSV parse error: Expected 1 columns, got 4: col1,col2,col3,col4"
+        pytest.skip(reason="https://github.com/apache/arrow/issues/38676")
+
+    with pytest.raises(ParserError, match=msg):
+        parser.read_csv(StringIO(data), index_col=0, on_bad_lines="error")
+
+
+def test_on_bad_lines_warn_correct_formatting(all_parsers):
+    # see gh-15925
+    parser = all_parsers
+    data = """1,2
+a,b
+a,b,c
+a,b,d
+a,b
+"""
+    expected = DataFrame({"1": "a", "2": ["b"] * 2})
+    match_msg = "Skipping line"
+
+    expected_warning = ParserWarning
+    if parser.engine == "pyarrow":
+        match_msg = "Expected 2 columns, but found 3: a,b,c"
+
+    with tm.assert_produces_warning(
+        expected_warning, match=match_msg, check_stacklevel=False
+    ):
+        result = parser.read_csv(StringIO(data), on_bad_lines="warn")
+    tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/conftest.py

@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from pandas.compat import HAS_PYARROW
+from pandas.compat._optional import VERSIONS
+
+from pandas import (
+    read_csv,
+    read_table,
+)
+import pandas._testing as tm
+
+
+class BaseParser:
+    engine: str | None = None
+    low_memory = True
+    float_precision_choices: list[str | None] = []
+
+    def update_kwargs(self, kwargs):
+        kwargs = kwargs.copy()
+        kwargs.update({"engine": self.engine, "low_memory": self.low_memory})
+
+        return kwargs
+
+    def read_csv(self, *args, **kwargs):
+        kwargs = self.update_kwargs(kwargs)
+        return read_csv(*args, **kwargs)
+
+    def read_csv_check_warnings(
+        self,
+        warn_type: type[Warning],
+        warn_msg: str,
+        *args,
+        raise_on_extra_warnings=True,
+        check_stacklevel: bool = True,
+        **kwargs,
+    ):
+        # We need to check the stacklevel here instead of in the tests
+        # since this is where read_csv is called and where the warning
+        # should point to.
+        kwargs = self.update_kwargs(kwargs)
+        with tm.assert_produces_warning(
+            warn_type,
+            match=warn_msg,
+            raise_on_extra_warnings=raise_on_extra_warnings,
+            check_stacklevel=check_stacklevel,
+        ):
+            return read_csv(*args, **kwargs)
+
+    def read_table(self, *args, **kwargs):
+        kwargs = self.update_kwargs(kwargs)
+        return read_table(*args, **kwargs)
+
+    def read_table_check_warnings(
+        self,
+        warn_type: type[Warning],
+        warn_msg: str,
+        *args,
+        raise_on_extra_warnings=True,
+        **kwargs,
+    ):
+        # We need to check the stacklevel here instead of in the tests
+        # since this is where read_table is called and where the warning
+        # should point to.
+        kwargs = self.update_kwargs(kwargs)
+        with tm.assert_produces_warning(
+            warn_type, match=warn_msg, raise_on_extra_warnings=raise_on_extra_warnings
+        ):
+            return read_table(*args, **kwargs)
+
+
+class CParser(BaseParser):
+    engine = "c"
+    float_precision_choices = [None, "high", "round_trip"]
+
+
+class CParserHighMemory(CParser):
+    low_memory = False
+
+
+class CParserLowMemory(CParser):
+    low_memory = True
+
+
+class PythonParser(BaseParser):
+    engine = "python"
+    float_precision_choices = [None]
+
+
+class PyArrowParser(BaseParser):
+    engine = "pyarrow"
+    float_precision_choices = [None]
+
+
+@pytest.fixture
+def csv_dir_path(datapath):
+    """
+    The directory path to the data files needed for parser tests.
+    """
+    return datapath("io", "parser", "data")
+
+
+@pytest.fixture
+def csv1(datapath):
+    """
+    The path to the data file "test1.csv" needed for parser tests.
+    """
+    return os.path.join(datapath("io", "data", "csv"), "test1.csv")
+
+
+_cParserHighMemory = CParserHighMemory
+_cParserLowMemory = CParserLowMemory
+_pythonParser = PythonParser
+_pyarrowParser = PyArrowParser
+
+_py_parsers_only = [_pythonParser]
+_c_parsers_only = [_cParserHighMemory, _cParserLowMemory]
+_pyarrow_parsers_only = [
+    pytest.param(
+        _pyarrowParser,
+        marks=[
+            pytest.mark.single_cpu,
+            pytest.mark.skipif(not HAS_PYARROW, reason="pyarrow is not installed"),
+        ],
+    )
+]
+
+_all_parsers = [*_c_parsers_only, *_py_parsers_only, *_pyarrow_parsers_only]
+
+_py_parser_ids = ["python"]
+_c_parser_ids = ["c_high", "c_low"]
+_pyarrow_parsers_ids = ["pyarrow"]
+
+_all_parser_ids = [*_c_parser_ids, *_py_parser_ids, *_pyarrow_parsers_ids]
+
+
+@pytest.fixture(params=_all_parsers, ids=_all_parser_ids)
+def all_parsers(request):
+    """
+    Fixture all of the CSV parsers.
+    """
+    parser = request.param()
+    if parser.engine == "pyarrow":
+        pytest.importorskip("pyarrow", VERSIONS["pyarrow"])
+        # Try finding a way to disable threads all together
+        # for more stable CI runs
+        import pyarrow
+
+        pyarrow.set_cpu_count(1)
+    return parser
+
+
+@pytest.fixture(params=_c_parsers_only, ids=_c_parser_ids)
+def c_parser_only(request):
+    """
+    Fixture all of the CSV parsers using the C engine.
+    """
+    return request.param()
+
+
+@pytest.fixture(params=_py_parsers_only, ids=_py_parser_ids)
+def python_parser_only(request):
+    """
+    Fixture all of the CSV parsers using the Python engine.
+    """
+    return request.param()
+
+
+@pytest.fixture(params=_pyarrow_parsers_only, ids=_pyarrow_parsers_ids)
+def pyarrow_parser_only(request):
+    """
+    Fixture all of the CSV parsers using the Pyarrow engine.
+    """
+    return request.param()
+
+
+def _get_all_parser_float_precision_combinations():
+    """
+    Return all allowable parser and float precision
+    combinations and corresponding ids.
+    """
+    params = []
+    ids = []
+    for parser, parser_id in zip(_all_parsers, _all_parser_ids):
+        if hasattr(parser, "values"):
+            # Wrapped in pytest.param, get the actual parser back
+            parser = parser.values[0]
+        for precision in parser.float_precision_choices:
+            # Re-wrap in pytest.param for pyarrow
+            mark = (
+                [
+                    pytest.mark.single_cpu,
+                    pytest.mark.skipif(
+                        not HAS_PYARROW, reason="pyarrow is not installed"
+                    ),
+                ]
+                if parser.engine == "pyarrow"
+                else ()
+            )
+            param = pytest.param((parser(), precision), marks=mark)
+            params.append(param)
+            ids.append(f"{parser_id}-{precision}")
+
+    return {"params": params, "ids": ids}
+
+
+@pytest.fixture(
+    params=_get_all_parser_float_precision_combinations()["params"],
+    ids=_get_all_parser_float_precision_combinations()["ids"],
+)
+def all_parsers_all_precisions(request):
+    """
+    Fixture for all allowable combinations of parser
+    and float precision
+    """
+    return request.param
+
+
+_utf_values = [8, 16, 32]
+
+_encoding_seps = ["", "-", "_"]
+_encoding_prefixes = ["utf", "UTF"]
+
+_encoding_fmts = [
+    f"{prefix}{sep}{{0}}" for sep in _encoding_seps for prefix in _encoding_prefixes
+]
+
+
+@pytest.fixture(params=_utf_values)
+def utf_value(request):
+    """
+    Fixture for all possible integer values for a UTF encoding.
+    """
+    return request.param
+
+
+@pytest.fixture(params=_encoding_fmts)
+def encoding_fmt(request):
+    """
+    Fixture for all possible string formats of a UTF encoding.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        ("-1,0", -1.0),
+        ("-1,2e0", -1.2),
+        ("-1e0", -1.0),
+        ("+1e0", 1.0),
+        ("+1e+0", 1.0),
+        ("+1e-1", 0.1),
+        ("+,1e1", 1.0),
+        ("+1,e0", 1.0),
+        ("-,1e1", -1.0),
+        ("-1,e0", -1.0),
+        ("0,1", 0.1),
+        ("1,", 1.0),
+        (",1", 0.1),
+        ("-,1", -0.1),
+        ("1_,", 1.0),
+        ("1_234,56", 1234.56),
+        ("1_234,56e0", 1234.56),
+        # negative cases; must not parse as float
+        ("_", "_"),
+        ("-_", "-_"),
+        ("-_1", "-_1"),
+        ("-_1e0", "-_1e0"),
+        ("_1", "_1"),
+        ("_1,", "_1,"),
+        ("_1,_", "_1,_"),
+        ("_1e0", "_1e0"),
+        ("1,2e_1", "1,2e_1"),
+        ("1,2e1_0", "1,2e1_0"),
+        ("1,_2", "1,_2"),
+        (",1__2", ",1__2"),
+        (",1e", ",1e"),
+        ("-,1e", "-,1e"),
+        ("1_000,000_000", "1_000,000_000"),
+        ("1,e1_2", "1,e1_2"),
+        ("e11,2", "e11,2"),
+        ("1e11,2", "1e11,2"),
+        ("1,2,2", "1,2,2"),
+        ("1,2_1", "1,2_1"),
+        ("1,2e-10e1", "1,2e-10e1"),
+        ("--1,2", "--1,2"),
+        ("1a_2,1", "1a_2,1"),
+        ("1,2E-1", 0.12),
+        ("1,2E1", 12.0),
+    ]
+)
+def numeric_decimal(request):
+    """
+    Fixture for all numeric formats which should get recognized. The first entry
+    represents the value to read while the second represents the expected result.
+    """
+    return request.param
+
+
+@pytest.fixture
+def pyarrow_xfail(request):
+    """
+    Fixture that xfails a test if the engine is pyarrow.
+
+    Use if failure is do to unsupported keywords or inconsistent results.
+    """
+    if "all_parsers" in request.fixturenames:
+        parser = request.getfixturevalue("all_parsers")
+    elif "all_parsers_all_precisions" in request.fixturenames:
+        # Return value is tuple of (engine, precision)
+        parser = request.getfixturevalue("all_parsers_all_precisions")[0]
+    else:
+        return
+    if parser.engine == "pyarrow":
+        mark = pytest.mark.xfail(reason="pyarrow doesn't support this.")
+        request.applymarker(mark)
+
+
+@pytest.fixture
+def pyarrow_skip(request):
+    """
+    Fixture that skips a test if the engine is pyarrow.
+
+    Use if failure is do a parsing failure from pyarrow.csv.read_csv
+    """
+    if "all_parsers" in request.fixturenames:
+        parser = request.getfixturevalue("all_parsers")
+    elif "all_parsers_all_precisions" in request.fixturenames:
+        # Return value is tuple of (engine, precision)
+        parser = request.getfixturevalue("all_parsers_all_precisions")[0]
+    else:
+        return
+    if parser.engine == "pyarrow":
+        pytest.skip(reason="https://github.com/apache/arrow/issues/38676")

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/dtypes/test_categorical.py

@@ -0,0 +1,338 @@
+"""
+Tests dtype specification during parsing
+for all of the parsers defined in parsers.py
+"""
+
+from io import StringIO
+import os
+
+import numpy as np
+import pytest
+
+from pandas._libs import parsers as libparsers
+from pandas.errors import Pandas4Warning
+
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Timestamp,
+)
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+
+
+@xfail_pyarrow  # AssertionError: Attributes of DataFrame.iloc[:, 0] are different
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        "category",
+        CategoricalDtype(),
+        {"a": "category", "b": "category", "c": CategoricalDtype()},
+    ],
+)
+def test_categorical_dtype(all_parsers, dtype):
+    # see gh-10153
+    parser = all_parsers
+    data = """a,b,c
+1,a,3.4
+1,a,3.4
+2,b,4.5"""
+    expected = DataFrame(
+        {
+            "a": Categorical(["1", "1", "2"]),
+            "b": Categorical(["a", "a", "b"]),
+            "c": Categorical(["3.4", "3.4", "4.5"]),
+        }
+    )
+    actual = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(actual, expected)
+
+
+@pytest.mark.parametrize("dtype", [{"b": "category"}, {1: "category"}])
+def test_categorical_dtype_single(all_parsers, dtype, request):
+    # see gh-10153
+    parser = all_parsers
+    data = """a,b,c
+1,a,3.4
+1,a,3.4
+2,b,4.5"""
+    expected = DataFrame(
+        {"a": [1, 1, 2], "b": Categorical(["a", "a", "b"]), "c": [3.4, 3.4, 4.5]}
+    )
+    if parser.engine == "pyarrow":
+        mark = pytest.mark.xfail(
+            strict=False,
+            reason="Flaky test sometimes gives object dtype instead of Categorical",
+        )
+        request.applymarker(mark)
+
+    actual = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(actual, expected)
+
+
+@xfail_pyarrow  # AssertionError: Attributes of DataFrame.iloc[:, 0] are different
+def test_categorical_dtype_unsorted(all_parsers):
+    # see gh-10153
+    parser = all_parsers
+    data = """a,b,c
+1,b,3.4
+1,b,3.4
+2,a,4.5"""
+    expected = DataFrame(
+        {
+            "a": Categorical(["1", "1", "2"]),
+            "b": Categorical(["b", "b", "a"]),
+            "c": Categorical(["3.4", "3.4", "4.5"]),
+        }
+    )
+    actual = parser.read_csv(StringIO(data), dtype="category")
+    tm.assert_frame_equal(actual, expected)
+
+
+@xfail_pyarrow  # AssertionError: Attributes of DataFrame.iloc[:, 0] are different
+def test_categorical_dtype_missing(all_parsers):
+    # see gh-10153
+    parser = all_parsers
+    data = """a,b,c
+1,b,3.4
+1,nan,3.4
+2,a,4.5"""
+    expected = DataFrame(
+        {
+            "a": Categorical(["1", "1", "2"]),
+            "b": Categorical(["b", np.nan, "a"]),
+            "c": Categorical(["3.4", "3.4", "4.5"]),
+        }
+    )
+    actual = parser.read_csv(StringIO(data), dtype="category")
+    tm.assert_frame_equal(actual, expected)
+
+
+@xfail_pyarrow  # AssertionError: Attributes of DataFrame.iloc[:, 0] are different
+@pytest.mark.slow
+def test_categorical_dtype_high_cardinality_numeric(all_parsers, monkeypatch):
+    # see gh-18186
+    # was an issue with C parser, due to DEFAULT_BUFFER_HEURISTIC
+    parser = all_parsers
+    heuristic = 2**5
+    data = np.sort([str(i) for i in range(heuristic + 1)])
+    expected = DataFrame({"a": Categorical(data, ordered=True)})
+    with monkeypatch.context() as m:
+        m.setattr(libparsers, "DEFAULT_BUFFER_HEURISTIC", heuristic)
+        actual = parser.read_csv(StringIO("a\n" + "\n".join(data)), dtype="category")
+    actual["a"] = actual["a"].cat.reorder_categories(
+        np.sort(actual.a.cat.categories), ordered=True
+    )
+    tm.assert_frame_equal(actual, expected)
+
+
+def test_categorical_dtype_utf16(all_parsers, csv_dir_path):
+    # see gh-10153
+    pth = os.path.join(csv_dir_path, "utf16_ex.txt")
+    parser = all_parsers
+    encoding = "utf-16"
+    sep = "\t"
+
+    expected = parser.read_csv(pth, sep=sep, encoding=encoding)
+    expected = expected.apply(Categorical)
+
+    actual = parser.read_csv(pth, sep=sep, encoding=encoding, dtype="category")
+    tm.assert_frame_equal(actual, expected)
+
+
+def test_categorical_dtype_chunksize_infer_categories(all_parsers):
+    # see gh-10153
+    parser = all_parsers
+    data = """a,b
+1,a
+1,b
+1,b
+2,c"""
+    expecteds = [
+        DataFrame({"a": [1, 1], "b": Categorical(["a", "b"])}),
+        DataFrame({"a": [1, 2], "b": Categorical(["b", "c"])}, index=[2, 3]),
+    ]
+
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), dtype={"b": "category"}, chunksize=2)
+        return
+
+    with parser.read_csv(
+        StringIO(data), dtype={"b": "category"}, chunksize=2
+    ) as actuals:
+        for actual, expected in zip(actuals, expecteds):
+            tm.assert_frame_equal(actual, expected)
+
+
+def test_categorical_dtype_chunksize_explicit_categories(all_parsers):
+    # see gh-10153
+    parser = all_parsers
+    data = """a,b
+1,a
+1,b
+1,b
+2,c"""
+    cats = ["a", "b", "c"]
+    expecteds = [
+        DataFrame({"a": [1, 1], "b": Categorical(["a", "b"], categories=cats)}),
+        DataFrame(
+            {"a": [1, 2], "b": Categorical(["b", "c"], categories=cats)},
+            index=[2, 3],
+        ),
+    ]
+    dtype = CategoricalDtype(cats)
+
+    if parser.engine == "pyarrow":
+        msg = "The 'chunksize' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), dtype={"b": dtype}, chunksize=2)
+        return
+
+    with parser.read_csv(StringIO(data), dtype={"b": dtype}, chunksize=2) as actuals:
+        for actual, expected in zip(actuals, expecteds):
+            tm.assert_frame_equal(actual, expected)
+
+
+def test_categorical_dtype_latin1(all_parsers, csv_dir_path):
+    # see gh-10153
+    pth = os.path.join(csv_dir_path, "unicode_series.csv")
+    parser = all_parsers
+    encoding = "latin-1"
+
+    expected = parser.read_csv(pth, header=None, encoding=encoding)
+    expected[1] = Categorical(expected[1])
+
+    actual = parser.read_csv(pth, header=None, encoding=encoding, dtype={1: "category"})
+    tm.assert_frame_equal(actual, expected)
+
+
+@pytest.mark.parametrize("ordered", [False, True])
+@pytest.mark.parametrize(
+    "categories",
+    [["a", "b", "c"], ["a", "c", "b"], ["a", "b", "c", "d"], ["c", "b", "a"]],
+)
+def test_categorical_category_dtype(all_parsers, categories, ordered):
+    parser = all_parsers
+    data = """a,b
+1,a
+1,b
+1,b
+2,c"""
+    expected = DataFrame(
+        {
+            "a": [1, 1, 1, 2],
+            "b": Categorical(
+                ["a", "b", "b", "c"], categories=categories, ordered=ordered
+            ),
+        }
+    )
+
+    dtype = {"b": CategoricalDtype(categories=categories, ordered=ordered)}
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_categorical_category_dtype_unsorted(all_parsers):
+    parser = all_parsers
+    data = """a,b
+1,a
+1,b
+1,b
+2,c"""
+    dtype = CategoricalDtype(["c", "b", "a"])
+    expected = DataFrame(
+        {
+            "a": [1, 1, 1, 2],
+            "b": Categorical(["a", "b", "b", "c"], categories=["c", "b", "a"]),
+        }
+    )
+
+    result = parser.read_csv(StringIO(data), dtype={"b": dtype})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_categorical_coerces_numeric(all_parsers):
+    parser = all_parsers
+    dtype = {"b": CategoricalDtype([1, 2, 3])}
+
+    data = "b\n1\n1\n2\n3"
+    expected = DataFrame({"b": Categorical([1, 1, 2, 3])})
+
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_categorical_coerces_datetime(all_parsers):
+    parser = all_parsers
+    dti = pd.DatetimeIndex(["2017-01-01", "2018-01-01", "2019-01-01"], freq=None)
+    dtype = {"b": CategoricalDtype(dti)}
+
+    data = "b\n2017-01-01\n2018-01-01\n2019-01-01"
+    expected = DataFrame({"b": Categorical(dtype["b"].categories)})
+
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_categorical_coerces_timestamp(all_parsers):
+    parser = all_parsers
+    dtype = {"b": CategoricalDtype([Timestamp("2014")])}
+
+    data = "b\n2014-01-01\n2014-01-01"
+    expected = DataFrame({"b": Categorical([Timestamp("2014")] * 2)})
+
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_categorical_coerces_timedelta(all_parsers):
+    parser = all_parsers
+    dtype = {"b": CategoricalDtype(pd.to_timedelta(["1h", "2h", "3h"]))}
+
+    data = "b\n1h\n2h\n3h"
+    expected = DataFrame({"b": Categorical(dtype["b"].categories)})
+
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        "b\nTrue\nFalse\nNA\nFalse",
+        "b\ntrue\nfalse\nNA\nfalse",
+        "b\nTRUE\nFALSE\nNA\nFALSE",
+        "b\nTrue\nFalse\nNA\nFALSE",
+    ],
+)
+def test_categorical_dtype_coerces_boolean(all_parsers, data):
+    # see gh-20498
+    parser = all_parsers
+    dtype = {"b": CategoricalDtype([False, True])}
+    expected = DataFrame({"b": Categorical([True, False, None, False])})
+
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_categorical_unexpected_categories(all_parsers):
+    parser = all_parsers
+    dtype = {"b": CategoricalDtype(["a", "b", "d", "e"])}
+
+    data = "b\nd\na\nc\nd"  # Unexpected c
+    expected = DataFrame({"b": Categorical(["d", "a", None, "d"], dtype=dtype["b"])})
+
+    msg = "Constructing a Categorical with a dtype and values containing"
+    with tm.assert_produces_warning(Pandas4Warning, match=msg, check_stacklevel=False):
+        result = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/dtypes/test_dtypes_basic.py

@@ -0,0 +1,639 @@
+"""
+Tests dtype specification during parsing
+for all of the parsers defined in parsers.py
+"""
+
+from collections import defaultdict
+from io import StringIO
+
+import numpy as np
+import pytest
+
+from pandas.errors import ParserWarning
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas.core.arrays import IntegerArray
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+
+
+@pytest.mark.parametrize("dtype", [str, object])
+@pytest.mark.parametrize("check_orig", [True, False])
+@pytest.mark.usefixtures("pyarrow_xfail")
+def test_dtype_all_columns(
+    all_parsers, dtype, check_orig, using_infer_string, temp_file
+):
+    # see gh-3795, gh-6607
+    parser = all_parsers
+
+    df = DataFrame(
+        np.random.default_rng(2).random((5, 2)).round(4),
+        columns=list("AB"),
+        index=["1A", "1B", "1C", "1D", "1E"],
+    )
+
+    df.to_csv(temp_file)
+
+    result = parser.read_csv(temp_file, dtype=dtype, index_col=0)
+
+    if check_orig:
+        expected = df.copy()
+        result = result.astype(float)
+    elif using_infer_string and dtype is str:
+        expected = df.astype(str)
+    else:
+        expected = df.astype(str).astype(object)
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+def test_dtype_per_column(all_parsers):
+    parser = all_parsers
+    data = """\
+one,two
+1,2.5
+2,3.5
+3,4.5
+4,5.5"""
+    expected = DataFrame(
+        [[1, "2.5"], [2, "3.5"], [3, "4.5"], [4, "5.5"]], columns=["one", "two"]
+    )
+    expected["one"] = expected["one"].astype(np.float64)
+
+    result = parser.read_csv(StringIO(data), dtype={"one": np.float64, 1: str})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_invalid_dtype_per_column(all_parsers):
+    parser = all_parsers
+    data = """\
+one,two
+1,2.5
+2,3.5
+3,4.5
+4,5.5"""
+
+    with pytest.raises(TypeError, match="data type [\"']foo[\"'] not understood"):
+        parser.read_csv(StringIO(data), dtype={"one": "foo", 1: "int"})
+
+
+def test_raise_on_passed_int_dtype_with_nas(all_parsers):
+    # see gh-2631
+    parser = all_parsers
+    data = """YEAR, DOY, a
+2001,106380451,10
+2001,,11
+2001,106380451,67"""
+
+    if parser.engine == "c":
+        msg = "Integer column has NA values"
+    elif parser.engine == "pyarrow":
+        msg = "The 'skipinitialspace' option is not supported with the 'pyarrow' engine"
+    else:
+        msg = "Unable to convert column DOY"
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(StringIO(data), dtype={"DOY": np.int64}, skipinitialspace=True)
+
+
+def test_dtype_with_converters(all_parsers):
+    parser = all_parsers
+    data = """a,b
+1.1,2.2
+1.2,2.3"""
+
+    if parser.engine == "pyarrow":
+        msg = "The 'converters' option is not supported with the 'pyarrow' engine"
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(
+                StringIO(data), dtype={"a": "i8"}, converters={"a": lambda x: str(x)}
+            )
+        return
+
+    # Dtype spec ignored if converted specified.
+    result = parser.read_csv_check_warnings(
+        ParserWarning,
+        "Both a converter and dtype were specified for column a "
+        "- only the converter will be used.",
+        StringIO(data),
+        dtype={"a": "i8"},
+        converters={"a": lambda x: str(x)},
+    )
+    expected = DataFrame({"a": ["1.1", "1.2"], "b": [2.2, 2.3]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_numeric_dtype(all_parsers, any_real_numpy_dtype):
+    data = "0\n1"
+    parser = all_parsers
+    expected = DataFrame([0, 1], dtype=any_real_numpy_dtype)
+
+    result = parser.read_csv(StringIO(data), header=None, dtype=any_real_numpy_dtype)
+    tm.assert_frame_equal(expected, result, check_column_type=False)
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+def test_boolean_dtype(all_parsers):
+    parser = all_parsers
+    data = "\n".join(
+        [
+            "a",
+            "True",
+            "TRUE",
+            "true",
+            "1",
+            "1.0",
+            "False",
+            "FALSE",
+            "false",
+            "0",
+            "0.0",
+            "NaN",
+            "nan",
+            "NA",
+            "null",
+            "NULL",
+        ]
+    )
+
+    result = parser.read_csv(StringIO(data), dtype="boolean")
+    expected = DataFrame(
+        {
+            "a": pd.array(
+                [
+                    True,
+                    True,
+                    True,
+                    True,
+                    True,
+                    False,
+                    False,
+                    False,
+                    False,
+                    False,
+                    None,
+                    None,
+                    None,
+                    None,
+                    None,
+                ],
+                dtype="boolean",
+            )
+        }
+    )
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+def test_delimiter_with_usecols_and_parse_dates(all_parsers):
+    # GH#35873
+    result = all_parsers.read_csv(
+        StringIO('"dump","-9,1","-9,1",20101010'),
+        engine="python",
+        names=["col", "col1", "col2", "col3"],
+        usecols=["col1", "col2", "col3"],
+        parse_dates=["col3"],
+        decimal=",",
+    )
+    expected = DataFrame(
+        {"col1": [-9.1], "col2": [-9.1], "col3": [Timestamp("2010-10-10")]}
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("thousands", ["_", None])
+def test_decimal_and_exponential(
+    request, python_parser_only, numeric_decimal, thousands
+):
+    # GH#31920
+    decimal_number_check(request, python_parser_only, numeric_decimal, thousands, None)
+
+
+@pytest.mark.parametrize("thousands", ["_", None])
+@pytest.mark.parametrize("float_precision", [None, "legacy", "high", "round_trip"])
+def test_1000_sep_decimal_float_precision(
+    request, c_parser_only, numeric_decimal, float_precision, thousands
+):
+    # test decimal and thousand sep handling in across 'float_precision'
+    # parsers
+    decimal_number_check(
+        request, c_parser_only, numeric_decimal, thousands, float_precision
+    )
+    text, value = numeric_decimal
+    text = " " + text + " "
+    if isinstance(value, str):  # the negative cases (parse as text)
+        value = " " + value + " "
+    decimal_number_check(
+        request, c_parser_only, (text, value), thousands, float_precision
+    )
+
+
+def decimal_number_check(request, parser, numeric_decimal, thousands, float_precision):
+    # GH#31920
+    value = numeric_decimal[0]
+    if thousands is None and value in ("1_,", "1_234,56", "1_234,56e0"):
+        request.applymarker(
+            pytest.mark.xfail(reason=f"thousands={thousands} and sep is in {value}")
+        )
+    df = parser.read_csv(
+        StringIO(value),
+        float_precision=float_precision,
+        sep="|",
+        thousands=thousands,
+        decimal=",",
+        header=None,
+    )
+    val = df.iloc[0, 0]
+    assert val == numeric_decimal[1]
+
+
+@pytest.mark.parametrize("float_precision", [None, "legacy", "high", "round_trip"])
+def test_skip_whitespace(c_parser_only, float_precision):
+    DATA = """id\tnum\t
+1\t1.2 \t
+1\t 2.1\t
+2\t 1\t
+2\t 1.2 \t
+"""
+    df = c_parser_only.read_csv(
+        StringIO(DATA),
+        float_precision=float_precision,
+        sep="\t",
+        header=0,
+        dtype={1: np.float64},
+    )
+    tm.assert_series_equal(df.iloc[:, 1], pd.Series([1.2, 2.1, 1.0, 1.2], name="num"))
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+def test_true_values_cast_to_bool(all_parsers):
+    # GH#34655
+    text = """a,b
+yes,xxx
+no,yyy
+1,zzz
+0,aaa
+    """
+    parser = all_parsers
+    result = parser.read_csv(
+        StringIO(text),
+        true_values=["yes"],
+        false_values=["no"],
+        dtype={"a": "boolean"},
+    )
+    expected = DataFrame(
+        {"a": [True, False, True, False], "b": ["xxx", "yyy", "zzz", "aaa"]}
+    )
+    expected["a"] = expected["a"].astype("boolean")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+@pytest.mark.parametrize("dtypes, exp_value", [({}, "1"), ({"a.1": "int64"}, 1)])
+def test_dtype_mangle_dup_cols(all_parsers, dtypes, exp_value):
+    # GH#35211
+    parser = all_parsers
+    data = """a,a\n1,1"""
+    dtype_dict = {"a": str, **dtypes}
+    # GH#42462
+    dtype_dict_copy = dtype_dict.copy()
+    result = parser.read_csv(StringIO(data), dtype=dtype_dict)
+    expected = DataFrame({"a": ["1"], "a.1": [exp_value]})
+    assert dtype_dict == dtype_dict_copy, "dtype dict changed"
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+def test_dtype_mangle_dup_cols_single_dtype(all_parsers):
+    # GH#42022
+    parser = all_parsers
+    data = """a,a\n1,1"""
+    result = parser.read_csv(StringIO(data), dtype=str)
+    expected = DataFrame({"a": ["1"], "a.1": ["1"]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+def test_dtype_multi_index(all_parsers):
+    # GH 42446
+    parser = all_parsers
+    data = "A,B,B\nX,Y,Z\n1,2,3"
+
+    result = parser.read_csv(
+        StringIO(data),
+        header=list(range(2)),
+        dtype={
+            ("A", "X"): np.int32,
+            ("B", "Y"): np.int32,
+            ("B", "Z"): np.float32,
+        },
+    )
+
+    expected = DataFrame(
+        {
+            ("A", "X"): np.int32([1]),
+            ("B", "Y"): np.int32([2]),
+            ("B", "Z"): np.float32([3]),
+        }
+    )
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_nullable_int_dtype(all_parsers, any_int_ea_dtype):
+    # GH 25472
+    parser = all_parsers
+    dtype = any_int_ea_dtype
+
+    data = """a,b,c
+,3,5
+1,,6
+2,4,"""
+    expected = DataFrame(
+        {
+            "a": pd.array([pd.NA, 1, 2], dtype=dtype),
+            "b": pd.array([3, pd.NA, 4], dtype=dtype),
+            "c": pd.array([5, 6, pd.NA], dtype=dtype),
+        }
+    )
+    actual = parser.read_csv(StringIO(data), dtype=dtype)
+    tm.assert_frame_equal(actual, expected)
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+@pytest.mark.parametrize("default", ["float", "float64"])
+def test_dtypes_defaultdict(all_parsers, default):
+    # GH#41574
+    data = """a,b
+1,2
+"""
+    dtype = defaultdict(lambda: default, a="int64")
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    expected = DataFrame({"a": [1], "b": 2.0})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+def test_dtypes_defaultdict_mangle_dup_cols(all_parsers):
+    # GH#41574
+    data = """a,b,a,b,b.1
+1,2,3,4,5
+"""
+    dtype = defaultdict(lambda: "float64", a="int64")
+    dtype["b.1"] = "int64"
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), dtype=dtype)
+    expected = DataFrame({"a": [1], "b": [2.0], "a.1": [3], "b.2": [4.0], "b.1": [5]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.usefixtures("pyarrow_xfail")
+def test_dtypes_defaultdict_invalid(all_parsers):
+    # GH#41574
+    data = """a,b
+1,2
+"""
+    dtype = defaultdict(lambda: "invalid_dtype", a="int64")
+    parser = all_parsers
+    with pytest.raises(TypeError, match="not understood"):
+        parser.read_csv(StringIO(data), dtype=dtype)
+
+
+def test_dtype_backend(all_parsers):
+    # GH#36712
+
+    parser = all_parsers
+
+    data = """a,b,c,d,e,f,g,h,i,j
+1,2.5,True,a,,,,,12-31-2019,
+3,4.5,False,b,6,7.5,True,a,12-31-2019,
+"""
+    result = parser.read_csv(
+        StringIO(data), dtype_backend="numpy_nullable", parse_dates=["i"]
+    )
+    expected = DataFrame(
+        {
+            "a": pd.Series([1, 3], dtype="Int64"),
+            "b": pd.Series([2.5, 4.5], dtype="Float64"),
+            "c": pd.Series([True, False], dtype="boolean"),
+            "d": pd.Series(["a", "b"], dtype="string"),
+            "e": pd.Series([pd.NA, 6], dtype="Int64"),
+            "f": pd.Series([pd.NA, 7.5], dtype="Float64"),
+            "g": pd.Series([pd.NA, True], dtype="boolean"),
+            "h": pd.Series([pd.NA, "a"], dtype="string"),
+            "i": pd.Series([Timestamp("2019-12-31")] * 2),
+            "j": pd.Series([pd.NA, pd.NA], dtype="Int64"),
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_dtype_backend_and_dtype(all_parsers):
+    # GH#36712
+
+    parser = all_parsers
+
+    data = """a,b
+1,2.5
+,
+"""
+    result = parser.read_csv(
+        StringIO(data), dtype_backend="numpy_nullable", dtype="float64"
+    )
+    expected = DataFrame({"a": [1.0, np.nan], "b": [2.5, np.nan]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_dtype_backend_string(all_parsers, string_storage):
+    # GH#36712
+    with pd.option_context("mode.string_storage", string_storage):
+        parser = all_parsers
+
+        data = """a,b
+a,x
+b,
+"""
+        result = parser.read_csv(StringIO(data), dtype_backend="numpy_nullable")
+
+        expected = DataFrame(
+            {
+                "a": pd.array(["a", "b"], dtype=pd.StringDtype(string_storage)),
+                "b": pd.array(["x", pd.NA], dtype=pd.StringDtype(string_storage)),
+            },
+        )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_dtype_backend_ea_dtype_specified(all_parsers):
+    # GH#491496
+    data = """a,b
+1,2
+"""
+    parser = all_parsers
+    result = parser.read_csv(
+        StringIO(data), dtype="Int64", dtype_backend="numpy_nullable"
+    )
+    expected = DataFrame({"a": [1], "b": 2}, dtype="Int64")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_dtype_backend_pyarrow(all_parsers, request):
+    # GH#36712
+    pa = pytest.importorskip("pyarrow")
+    parser = all_parsers
+
+    data = """a,b,c,d,e,f,g,h,i,j
+1,2.5,True,a,,,,,12-31-2019,
+3,4.5,False,b,6,7.5,True,a,12-31-2019,
+"""
+    result = parser.read_csv(StringIO(data), dtype_backend="pyarrow", parse_dates=["i"])
+    expected = DataFrame(
+        {
+            "a": pd.Series([1, 3], dtype="int64[pyarrow]"),
+            "b": pd.Series([2.5, 4.5], dtype="float64[pyarrow]"),
+            "c": pd.Series([True, False], dtype="bool[pyarrow]"),
+            "d": pd.Series(["a", "b"], dtype=pd.ArrowDtype(pa.string())),
+            "e": pd.Series([pd.NA, 6], dtype="int64[pyarrow]"),
+            "f": pd.Series([pd.NA, 7.5], dtype="float64[pyarrow]"),
+            "g": pd.Series([pd.NA, True], dtype="bool[pyarrow]"),
+            "h": pd.Series(
+                [pd.NA, "a"],
+                dtype=pd.ArrowDtype(pa.string()),
+            ),
+            "i": pd.Series([Timestamp("2019-12-31")] * 2),
+            "j": pd.Series([pd.NA, pd.NA], dtype="null[pyarrow]"),
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_ea_int_avoid_overflow(all_parsers):
+    # GH#32134
+    parser = all_parsers
+    data = """a,b
+1,1
+,1
+1582218195625938945,1
+"""
+    result = parser.read_csv(StringIO(data), dtype={"a": "Int64"})
+    expected = DataFrame(
+        {
+            "a": IntegerArray(
+                np.array([1, 1, 1582218195625938945]), np.array([False, True, False])
+            ),
+            "b": 1,
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_string_inference(all_parsers):
+    # GH#54430
+    dtype = pd.StringDtype(na_value=np.nan)
+
+    data = """a,b
+x,1
+y,2
+,3"""
+    parser = all_parsers
+    with pd.option_context("future.infer_string", True):
+        result = parser.read_csv(StringIO(data))
+
+    expected = DataFrame(
+        {"a": pd.Series(["x", "y", None], dtype=dtype), "b": [1, 2, 3]},
+        columns=pd.Index(["a", "b"], dtype=dtype),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["O", object, "object", np.object_, str, np.str_])
+def test_string_inference_object_dtype(all_parsers, dtype, using_infer_string):
+    # GH#56047
+    data = """a,b
+x,a
+y,a
+z,a"""
+    parser = all_parsers
+    with pd.option_context("future.infer_string", True):
+        result = parser.read_csv(StringIO(data), dtype=dtype)
+
+    expected_dtype = pd.StringDtype(na_value=np.nan) if dtype is str else object
+    expected = DataFrame(
+        {
+            "a": pd.Series(["x", "y", "z"], dtype=expected_dtype),
+            "b": pd.Series(["a", "a", "a"], dtype=expected_dtype),
+        },
+        columns=pd.Index(["a", "b"], dtype=pd.StringDtype(na_value=np.nan)),
+    )
+    tm.assert_frame_equal(result, expected)
+
+    with pd.option_context("future.infer_string", True):
+        result = parser.read_csv(StringIO(data), dtype={"a": dtype})
+
+    expected = DataFrame(
+        {
+            "a": pd.Series(["x", "y", "z"], dtype=expected_dtype),
+            "b": pd.Series(["a", "a", "a"], dtype=pd.StringDtype(na_value=np.nan)),
+        },
+        columns=pd.Index(["a", "b"], dtype=pd.StringDtype(na_value=np.nan)),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_accurate_parsing_of_large_integers(all_parsers):
+    # GH#52505
+    data = """SYMBOL,MOMENT,ID,ID_DEAL
+AAPL,20230301181139587,1925036343869802844,
+AAPL,20230301181139587,2023552585717889863,2023552585717263358
+NVDA,20230301181139587,2023552585717889863,2023552585717263359
+AMC,20230301181139587,2023552585717889863,2023552585717263360
+AMZN,20230301181139587,2023552585717889759,2023552585717263360
+MSFT,20230301181139587,2023552585717889863,2023552585717263361
+NVDA,20230301181139587,2023552585717889827,2023552585717263361"""
+    orders = all_parsers.read_csv(StringIO(data), dtype={"ID_DEAL": pd.Int64Dtype()})
+    assert len(orders.loc[orders["ID_DEAL"] == 2023552585717263358, "ID_DEAL"]) == 1
+    assert len(orders.loc[orders["ID_DEAL"] == 2023552585717263359, "ID_DEAL"]) == 1
+    assert len(orders.loc[orders["ID_DEAL"] == 2023552585717263360, "ID_DEAL"]) == 2
+    assert len(orders.loc[orders["ID_DEAL"] == 2023552585717263361, "ID_DEAL"]) == 2
+
+
+def test_dtypes_with_usecols(all_parsers):
+    # GH#54868
+
+    parser = all_parsers
+    data = """a,b,c
+1,2,3
+4,5,6"""
+
+    result = parser.read_csv(StringIO(data), usecols=["a", "c"], dtype={"a": object})
+    if parser.engine == "pyarrow":
+        values = [1, 4]
+    else:
+        values = ["1", "4"]
+    expected = DataFrame({"a": pd.Series(values, dtype=object), "c": [3, 6]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_index_col_with_dtype_no_rangeindex(all_parsers):
+    data = StringIO("345.5,519.5,0\n519.5,726.5,1")
+    result = all_parsers.read_csv(
+        data,
+        header=None,
+        names=["start", "stop", "bin_id"],
+        dtype={"start": np.float32, "stop": np.float32, "bin_id": np.uint32},
+        index_col="bin_id",
+    ).index
+    expected = pd.Index([0, 1], dtype=np.uint32, name="bin_id")
+    tm.assert_index_equal(result, expected)

.venv/lib/python3.13/site-packages/pandas/tests/io/parser/dtypes/test_empty.py

@@ -0,0 +1,181 @@
+"""
+Tests dtype specification during parsing
+for all of the parsers defined in parsers.py
+"""
+
+from io import StringIO
+
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    concat,
+)
+import pandas._testing as tm
+
+skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+def test_dtype_all_columns_empty(all_parsers):
+    # see gh-12048
+    parser = all_parsers
+    result = parser.read_csv(StringIO("A,B"), dtype=str)
+
+    expected = DataFrame({"A": [], "B": []}, dtype=str)
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+def test_empty_pass_dtype(all_parsers):
+    parser = all_parsers
+
+    data = "one,two"
+    result = parser.read_csv(StringIO(data), dtype={"one": "u1"})
+
+    expected = DataFrame(
+        {"one": np.empty(0, dtype="u1"), "two": np.empty(0, dtype=object)},
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+def test_empty_with_index_pass_dtype(all_parsers):
+    parser = all_parsers
+
+    data = "one,two"
+    result = parser.read_csv(
+        StringIO(data), index_col=["one"], dtype={"one": "u1", 1: "f"}
+    )
+
+    expected = DataFrame(
+        {"two": np.empty(0, dtype="f")}, index=Index([], dtype="u1", name="one")
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+def test_empty_with_multi_index_pass_dtype(all_parsers):
+    parser = all_parsers
+
+    data = "one,two,three"
+    result = parser.read_csv(
+        StringIO(data), index_col=["one", "two"], dtype={"one": "u1", 1: "f8"}
+    )
+
+    exp_idx = MultiIndex.from_arrays(
+        [np.empty(0, dtype="u1"), np.empty(0, dtype=np.float64)],
+        names=["one", "two"],
+    )
+    expected = DataFrame({"three": np.empty(0, dtype=object)}, index=exp_idx)
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+def test_empty_with_mangled_column_pass_dtype_by_names(all_parsers):
+    parser = all_parsers
+
+    data = "one,one"
+    result = parser.read_csv(StringIO(data), dtype={"one": "u1", "one.1": "f"})
+
+    expected = DataFrame(
+        {"one": np.empty(0, dtype="u1"), "one.1": np.empty(0, dtype="f")},
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+def test_empty_with_mangled_column_pass_dtype_by_indexes(all_parsers):
+    parser = all_parsers
+
+    data = "one,one"
+    result = parser.read_csv(StringIO(data), dtype={0: "u1", 1: "f"})
+
+    expected = DataFrame(
+        {"one": np.empty(0, dtype="u1"), "one.1": np.empty(0, dtype="f")},
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+def test_empty_with_dup_column_pass_dtype_by_indexes(all_parsers):
+    # see gh-9424
+    parser = all_parsers
+    expected = concat(
+        [Series([], name="one", dtype="u1"), Series([], name="one.1", dtype="f")],
+        axis=1,
+    )
+
+    data = "one,one"
+    result = parser.read_csv(StringIO(data), dtype={0: "u1", 1: "f"})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_empty_with_dup_column_pass_dtype_by_indexes_raises(all_parsers):
+    # see gh-9424
+    parser = all_parsers
+    expected = concat(
+        [Series([], name="one", dtype="u1"), Series([], name="one.1", dtype="f")],
+        axis=1,
+    )
+    expected.index = expected.index.astype(object)
+
+    with pytest.raises(ValueError, match="Duplicate names"):
+        parser.read_csv(StringIO(""), names=["one", "one"], dtype={0: "u1", 1: "f"})
+
+
+@pytest.mark.parametrize(
+    "dtype,expected",
+    [
+        (np.float64, DataFrame(columns=["a", "b"], dtype=np.float64)),
+        (
+            "category",
+            DataFrame({"a": Categorical([]), "b": Categorical([])}),
+        ),
+        (
+            {"a": "category", "b": "category"},
+            DataFrame({"a": Categorical([]), "b": Categorical([])}),
+        ),
+        ("datetime64[ns]", DataFrame(columns=["a", "b"], dtype="datetime64[ns]")),
+        (
+            "timedelta64[ns]",
+            DataFrame(
+                {
+                    "a": Series([], dtype="timedelta64[ns]"),
+                    "b": Series([], dtype="timedelta64[ns]"),
+                },
+            ),
+        ),
+        (
+            {"a": np.int64, "b": np.int32},
+            DataFrame(
+                {"a": Series([], dtype=np.int64), "b": Series([], dtype=np.int32)},
+            ),
+        ),
+        (
+            {0: np.int64, 1: np.int32},
+            DataFrame(
+                {"a": Series([], dtype=np.int64), "b": Series([], dtype=np.int32)},
+            ),
+        ),
+        (
+            {"a": np.int64, 1: np.int32},
+            DataFrame(
+                {"a": Series([], dtype=np.int64), "b": Series([], dtype=np.int32)},
+            ),
+        ),
+    ],
+)
+@skip_pyarrow  # CSV parse error: Empty CSV file or block
+def test_empty_dtype(all_parsers, dtype, expected):
+    # see gh-14712
+    parser = all_parsers
+    data = "a,b"
+
+    result = parser.read_csv(StringIO(data), header=0, dtype=dtype)
+    tm.assert_frame_equal(result, expected)