Add files using upload-large-folder tool

videochat2/lib/python3.10/site-packages/pandas/tests/io/excel/conftest.py

@@ -0,0 +1,41 @@
+import pytest
+
+import pandas._testing as tm
+
+from pandas.io.parsers import read_csv
+
+
+@pytest.fixture
+def frame(float_frame):
+    """
+    Returns the first ten items in fixture "float_frame".
+    """
+    return float_frame[:10]
+
+
+@pytest.fixture
+def tsframe():
+    return tm.makeTimeDataFrame()[:5]
+
+
+@pytest.fixture(params=[True, False])
+def merge_cells(request):
+    return request.param
+
+
+@pytest.fixture
+def df_ref(datapath):
+    """
+    Obtain the reference data from read_csv with the Python engine.
+    """
+    filepath = datapath("io", "data", "csv", "test1.csv")
+    df_ref = read_csv(filepath, index_col=0, parse_dates=True, engine="python")
+    return df_ref
+
+
+@pytest.fixture(params=[".xls", ".xlsx", ".xlsm", ".ods", ".xlsb"])
+def read_ext(request):
+    """
+    Valid extensions for reading Excel files.
+    """
+    return request.param

videochat2/lib/python3.10/site-packages/pandas/tests/io/excel/test_openpyxl.py

@@ -0,0 +1,398 @@
+import contextlib
+from pathlib import Path
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+
+from pandas.io.excel import (
+    ExcelWriter,
+    _OpenpyxlWriter,
+)
+
+openpyxl = pytest.importorskip("openpyxl")
+
+pytestmark = pytest.mark.parametrize("ext", [".xlsx"])
+
+
+def test_to_excel_styleconverter(ext):
+    from openpyxl import styles
+
+    hstyle = {
+        "font": {"color": "00FF0000", "bold": True},
+        "borders": {"top": "thin", "right": "thin", "bottom": "thin", "left": "thin"},
+        "alignment": {"horizontal": "center", "vertical": "top"},
+        "fill": {"patternType": "solid", "fgColor": {"rgb": "006666FF", "tint": 0.3}},
+        "number_format": {"format_code": "0.00"},
+        "protection": {"locked": True, "hidden": False},
+    }
+
+    font_color = styles.Color("00FF0000")
+    font = styles.Font(bold=True, color=font_color)
+    side = styles.Side(style=styles.borders.BORDER_THIN)
+    border = styles.Border(top=side, right=side, bottom=side, left=side)
+    alignment = styles.Alignment(horizontal="center", vertical="top")
+    fill_color = styles.Color(rgb="006666FF", tint=0.3)
+    fill = styles.PatternFill(patternType="solid", fgColor=fill_color)
+
+    number_format = "0.00"
+
+    protection = styles.Protection(locked=True, hidden=False)
+
+    kw = _OpenpyxlWriter._convert_to_style_kwargs(hstyle)
+    assert kw["font"] == font
+    assert kw["border"] == border
+    assert kw["alignment"] == alignment
+    assert kw["fill"] == fill
+    assert kw["number_format"] == number_format
+    assert kw["protection"] == protection
+
+
+def test_write_cells_merge_styled(ext):
+    from pandas.io.formats.excel import ExcelCell
+
+    sheet_name = "merge_styled"
+
+    sty_b1 = {"font": {"color": "00FF0000"}}
+    sty_a2 = {"font": {"color": "0000FF00"}}
+
+    initial_cells = [
+        ExcelCell(col=1, row=0, val=42, style=sty_b1),
+        ExcelCell(col=0, row=1, val=99, style=sty_a2),
+    ]
+
+    sty_merged = {"font": {"color": "000000FF", "bold": True}}
+    sty_kwargs = _OpenpyxlWriter._convert_to_style_kwargs(sty_merged)
+    openpyxl_sty_merged = sty_kwargs["font"]
+    merge_cells = [
+        ExcelCell(
+            col=0, row=0, val="pandas", mergestart=1, mergeend=1, style=sty_merged
+        )
+    ]
+
+    with tm.ensure_clean(ext) as path:
+        with _OpenpyxlWriter(path) as writer:
+            writer._write_cells(initial_cells, sheet_name=sheet_name)
+            writer._write_cells(merge_cells, sheet_name=sheet_name)
+
+            wks = writer.sheets[sheet_name]
+        xcell_b1 = wks["B1"]
+        xcell_a2 = wks["A2"]
+        assert xcell_b1.font == openpyxl_sty_merged
+        assert xcell_a2.font == openpyxl_sty_merged
+
+
+@pytest.mark.parametrize("iso_dates", [True, False])
+def test_engine_kwargs_write(ext, iso_dates):
+    # GH 42286 GH 43445
+    engine_kwargs = {"iso_dates": iso_dates}
+    with tm.ensure_clean(ext) as f:
+        with ExcelWriter(f, engine="openpyxl", engine_kwargs=engine_kwargs) as writer:
+            assert writer.book.iso_dates == iso_dates
+            # ExcelWriter won't allow us to close without writing something
+            DataFrame().to_excel(writer)
+
+
+def test_engine_kwargs_append_invalid(ext):
+    # GH 43445
+    # test whether an invalid engine kwargs actually raises
+    with tm.ensure_clean(ext) as f:
+        DataFrame(["hello", "world"]).to_excel(f)
+        with pytest.raises(
+            TypeError,
+            match=re.escape(
+                "load_workbook() got an unexpected keyword argument 'apple_banana'"
+            ),
+        ):
+            with ExcelWriter(
+                f, engine="openpyxl", mode="a", engine_kwargs={"apple_banana": "fruit"}
+            ) as writer:
+                # ExcelWriter needs us to write something to close properly
+                DataFrame(["good"]).to_excel(writer, sheet_name="Sheet2")
+
+
+@pytest.mark.parametrize("data_only, expected", [(True, 0), (False, "=1+1")])
+def test_engine_kwargs_append_data_only(ext, data_only, expected):
+    # GH 43445
+    # tests whether the data_only engine_kwarg actually works well for
+    # openpyxl's load_workbook
+    with tm.ensure_clean(ext) as f:
+        DataFrame(["=1+1"]).to_excel(f)
+        with ExcelWriter(
+            f, engine="openpyxl", mode="a", engine_kwargs={"data_only": data_only}
+        ) as writer:
+            assert writer.sheets["Sheet1"]["B2"].value == expected
+            # ExcelWriter needs us to writer something to close properly?
+            DataFrame().to_excel(writer, sheet_name="Sheet2")
+
+
+@pytest.mark.parametrize(
+    "mode,expected", [("w", ["baz"]), ("a", ["foo", "bar", "baz"])]
+)
+def test_write_append_mode(ext, mode, expected):
+    df = DataFrame([1], columns=["baz"])
+
+    with tm.ensure_clean(ext) as f:
+        wb = openpyxl.Workbook()
+        wb.worksheets[0].title = "foo"
+        wb.worksheets[0]["A1"].value = "foo"
+        wb.create_sheet("bar")
+        wb.worksheets[1]["A1"].value = "bar"
+        wb.save(f)
+
+        with ExcelWriter(f, engine="openpyxl", mode=mode) as writer:
+            df.to_excel(writer, sheet_name="baz", index=False)
+
+        with contextlib.closing(openpyxl.load_workbook(f)) as wb2:
+            result = [sheet.title for sheet in wb2.worksheets]
+            assert result == expected
+
+            for index, cell_value in enumerate(expected):
+                assert wb2.worksheets[index]["A1"].value == cell_value
+
+
+@pytest.mark.parametrize(
+    "if_sheet_exists,num_sheets,expected",
+    [
+        ("new", 2, ["apple", "banana"]),
+        ("replace", 1, ["pear"]),
+        ("overlay", 1, ["pear", "banana"]),
+    ],
+)
+def test_if_sheet_exists_append_modes(ext, if_sheet_exists, num_sheets, expected):
+    # GH 40230
+    df1 = DataFrame({"fruit": ["apple", "banana"]})
+    df2 = DataFrame({"fruit": ["pear"]})
+
+    with tm.ensure_clean(ext) as f:
+        df1.to_excel(f, engine="openpyxl", sheet_name="foo", index=False)
+        with ExcelWriter(
+            f, engine="openpyxl", mode="a", if_sheet_exists=if_sheet_exists
+        ) as writer:
+            df2.to_excel(writer, sheet_name="foo", index=False)
+
+        with contextlib.closing(openpyxl.load_workbook(f)) as wb:
+            assert len(wb.sheetnames) == num_sheets
+            assert wb.sheetnames[0] == "foo"
+            result = pd.read_excel(wb, "foo", engine="openpyxl")
+            assert list(result["fruit"]) == expected
+            if len(wb.sheetnames) == 2:
+                result = pd.read_excel(wb, wb.sheetnames[1], engine="openpyxl")
+                tm.assert_frame_equal(result, df2)
+
+
+@pytest.mark.parametrize(
+    "startrow, startcol, greeting, goodbye",
+    [
+        (0, 0, ["poop", "world"], ["goodbye", "people"]),
+        (0, 1, ["hello", "world"], ["poop", "people"]),
+        (1, 0, ["hello", "poop"], ["goodbye", "people"]),
+        (1, 1, ["hello", "world"], ["goodbye", "poop"]),
+    ],
+)
+def test_append_overlay_startrow_startcol(ext, startrow, startcol, greeting, goodbye):
+    df1 = DataFrame({"greeting": ["hello", "world"], "goodbye": ["goodbye", "people"]})
+    df2 = DataFrame(["poop"])
+
+    with tm.ensure_clean(ext) as f:
+        df1.to_excel(f, engine="openpyxl", sheet_name="poo", index=False)
+        with ExcelWriter(
+            f, engine="openpyxl", mode="a", if_sheet_exists="overlay"
+        ) as writer:
+            # use startrow+1 because we don't have a header
+            df2.to_excel(
+                writer,
+                index=False,
+                header=False,
+                startrow=startrow + 1,
+                startcol=startcol,
+                sheet_name="poo",
+            )
+
+        result = pd.read_excel(f, sheet_name="poo", engine="openpyxl")
+        expected = DataFrame({"greeting": greeting, "goodbye": goodbye})
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "if_sheet_exists,msg",
+    [
+        (
+            "invalid",
+            "'invalid' is not valid for if_sheet_exists. Valid options "
+            "are 'error', 'new', 'replace' and 'overlay'.",
+        ),
+        (
+            "error",
+            "Sheet 'foo' already exists and if_sheet_exists is set to 'error'.",
+        ),
+        (
+            None,
+            "Sheet 'foo' already exists and if_sheet_exists is set to 'error'.",
+        ),
+    ],
+)
+def test_if_sheet_exists_raises(ext, if_sheet_exists, msg):
+    # GH 40230
+    df = DataFrame({"fruit": ["pear"]})
+    with tm.ensure_clean(ext) as f:
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            df.to_excel(f, "foo", engine="openpyxl")
+            with ExcelWriter(
+                f, engine="openpyxl", mode="a", if_sheet_exists=if_sheet_exists
+            ) as writer:
+                df.to_excel(writer, sheet_name="foo")
+
+
+def test_to_excel_with_openpyxl_engine(ext):
+    # GH 29854
+    with tm.ensure_clean(ext) as filename:
+        df1 = DataFrame({"A": np.linspace(1, 10, 10)})
+        df2 = DataFrame({"B": np.linspace(1, 20, 10)})
+        df = pd.concat([df1, df2], axis=1)
+        styled = df.style.applymap(
+            lambda val: f"color: {'red' if val < 0 else 'black'}"
+        ).highlight_max()
+
+        styled.to_excel(filename, engine="openpyxl")
+
+
+@pytest.mark.parametrize("read_only", [True, False])
+def test_read_workbook(datapath, ext, read_only):
+    # GH 39528
+    filename = datapath("io", "data", "excel", "test1" + ext)
+    with contextlib.closing(
+        openpyxl.load_workbook(filename, read_only=read_only)
+    ) as wb:
+        result = pd.read_excel(wb, engine="openpyxl")
+    expected = pd.read_excel(filename)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "header, expected_data",
+    [
+        (
+            0,
+            {
+                "Title": [np.nan, "A", 1, 2, 3],
+                "Unnamed: 1": [np.nan, "B", 4, 5, 6],
+                "Unnamed: 2": [np.nan, "C", 7, 8, 9],
+            },
+        ),
+        (2, {"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]}),
+    ],
+)
+@pytest.mark.parametrize(
+    "filename", ["dimension_missing", "dimension_small", "dimension_large"]
+)
+# When read_only is None, use read_excel instead of a workbook
+@pytest.mark.parametrize("read_only", [True, False, None])
+def test_read_with_bad_dimension(
+    datapath, ext, header, expected_data, filename, read_only
+):
+    # GH 38956, 39001 - no/incorrect dimension information
+    path = datapath("io", "data", "excel", f"{filename}{ext}")
+    if read_only is None:
+        result = pd.read_excel(path, header=header)
+    else:
+        with contextlib.closing(
+            openpyxl.load_workbook(path, read_only=read_only)
+        ) as wb:
+            result = pd.read_excel(wb, engine="openpyxl", header=header)
+    expected = DataFrame(expected_data)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_append_mode_file(ext):
+    # GH 39576
+    df = DataFrame()
+
+    with tm.ensure_clean(ext) as f:
+        df.to_excel(f, engine="openpyxl")
+
+        with ExcelWriter(
+            f, mode="a", engine="openpyxl", if_sheet_exists="new"
+        ) as writer:
+            df.to_excel(writer)
+
+        # make sure that zip files are not concatenated by making sure that
+        # "docProps/app.xml" only occurs twice in the file
+        data = Path(f).read_bytes()
+        first = data.find(b"docProps/app.xml")
+        second = data.find(b"docProps/app.xml", first + 1)
+        third = data.find(b"docProps/app.xml", second + 1)
+        assert second != -1 and third == -1
+
+
+# When read_only is None, use read_excel instead of a workbook
+@pytest.mark.parametrize("read_only", [True, False, None])
+def test_read_with_empty_trailing_rows(datapath, ext, read_only):
+    # GH 39181
+    path = datapath("io", "data", "excel", f"empty_trailing_rows{ext}")
+    if read_only is None:
+        result = pd.read_excel(path)
+    else:
+        with contextlib.closing(
+            openpyxl.load_workbook(path, read_only=read_only)
+        ) as wb:
+            result = pd.read_excel(wb, engine="openpyxl")
+    expected = DataFrame(
+        {
+            "Title": [np.nan, "A", 1, 2, 3],
+            "Unnamed: 1": [np.nan, "B", 4, 5, 6],
+            "Unnamed: 2": [np.nan, "C", 7, 8, 9],
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+# When read_only is None, use read_excel instead of a workbook
+@pytest.mark.parametrize("read_only", [True, False, None])
+def test_read_empty_with_blank_row(datapath, ext, read_only):
+    # GH 39547 - empty excel file with a row that has no data
+    path = datapath("io", "data", "excel", f"empty_with_blank_row{ext}")
+    if read_only is None:
+        result = pd.read_excel(path)
+    else:
+        with contextlib.closing(
+            openpyxl.load_workbook(path, read_only=read_only)
+        ) as wb:
+            result = pd.read_excel(wb, engine="openpyxl")
+    expected = DataFrame()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_book_and_sheets_consistent(ext):
+    # GH#45687 - Ensure sheets is updated if user modifies book
+    with tm.ensure_clean(ext) as f:
+        with ExcelWriter(f, engine="openpyxl") as writer:
+            assert writer.sheets == {}
+            sheet = writer.book.create_sheet("test_name", 0)
+            assert writer.sheets == {"test_name": sheet}
+
+
+def test_ints_spelled_with_decimals(datapath, ext):
+    # GH 46988 - openpyxl returns this sheet with floats
+    path = datapath("io", "data", "excel", f"ints_spelled_with_decimals{ext}")
+    result = pd.read_excel(path)
+    expected = DataFrame(range(2, 12), columns=[1])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_multiindex_header_no_index_names(datapath, ext):
+    # GH#47487
+    path = datapath("io", "data", "excel", f"multiindex_no_index_names{ext}")
+    result = pd.read_excel(path, index_col=[0, 1, 2], header=[0, 1, 2])
+    expected = DataFrame(
+        [[np.nan, "x", "x", "x"], ["x", np.nan, np.nan, np.nan]],
+        columns=pd.MultiIndex.from_tuples(
+            [("X", "Y", "A1"), ("X", "Y", "A2"), ("XX", "YY", "B1"), ("XX", "YY", "B2")]
+        ),
+        index=pd.MultiIndex.from_tuples([("A", "AA", "AAA"), ("A", "BB", "BBB")]),
+    )
+    tm.assert_frame_equal(result, expected)

videochat2/lib/python3.10/site-packages/pandas/tests/io/excel/test_readers.py

@@ -0,0 +1,1674 @@
+from datetime import (
+    datetime,
+    time,
+)
+from functools import partial
+import os
+from pathlib import Path
+import platform
+from urllib.error import URLError
+from zipfile import BadZipFile
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    ArrowStringArray,
+    StringArray,
+)
+
+read_ext_params = [".xls", ".xlsx", ".xlsm", ".xlsb", ".ods"]
+engine_params = [
+    # Add any engines to test here
+    # When defusedxml is installed it triggers deprecation warnings for
+    # xlrd and openpyxl, so catch those here
+    pytest.param(
+        "xlrd",
+        marks=[
+            td.skip_if_no("xlrd"),
+        ],
+    ),
+    pytest.param(
+        "openpyxl",
+        marks=[
+            td.skip_if_no("openpyxl"),
+        ],
+    ),
+    pytest.param(
+        None,
+        marks=[
+            td.skip_if_no("xlrd"),
+        ],
+    ),
+    pytest.param("pyxlsb", marks=td.skip_if_no("pyxlsb")),
+    pytest.param("odf", marks=td.skip_if_no("odf")),
+]
+
+
+def _is_valid_engine_ext_pair(engine, read_ext: str) -> bool:
+    """
+    Filter out invalid (engine, ext) pairs instead of skipping, as that
+    produces 500+ pytest.skips.
+    """
+    engine = engine.values[0]
+    if engine == "openpyxl" and read_ext == ".xls":
+        return False
+    if engine == "odf" and read_ext != ".ods":
+        return False
+    if read_ext == ".ods" and engine != "odf":
+        return False
+    if engine == "pyxlsb" and read_ext != ".xlsb":
+        return False
+    if read_ext == ".xlsb" and engine != "pyxlsb":
+        return False
+    if engine == "xlrd" and read_ext != ".xls":
+        return False
+    return True
+
+
+def _transfer_marks(engine, read_ext):
+    """
+    engine gives us a pytest.param object with some marks, read_ext is just
+    a string.  We need to generate a new pytest.param inheriting the marks.
+    """
+    values = engine.values + (read_ext,)
+    new_param = pytest.param(values, marks=engine.marks)
+    return new_param
+
+
+@pytest.fixture(
+    params=[
+        _transfer_marks(eng, ext)
+        for eng in engine_params
+        for ext in read_ext_params
+        if _is_valid_engine_ext_pair(eng, ext)
+    ],
+    ids=str,
+)
+def engine_and_read_ext(request):
+    """
+    Fixture for Excel reader engine and read_ext, only including valid pairs.
+    """
+    return request.param
+
+
+@pytest.fixture
+def engine(engine_and_read_ext):
+    engine, read_ext = engine_and_read_ext
+    return engine
+
+
+@pytest.fixture
+def read_ext(engine_and_read_ext):
+    engine, read_ext = engine_and_read_ext
+    return read_ext
+
+
+class TestReaders:
+    @pytest.fixture(autouse=True)
+    def cd_and_set_engine(self, engine, datapath, monkeypatch):
+        """
+        Change directory and set engine for read_excel calls.
+        """
+        func = partial(pd.read_excel, engine=engine)
+        monkeypatch.chdir(datapath("io", "data", "excel"))
+        monkeypatch.setattr(pd, "read_excel", func)
+
+    def test_engine_used(self, read_ext, engine, monkeypatch):
+        # GH 38884
+        def parser(self, *args, **kwargs):
+            return self.engine
+
+        monkeypatch.setattr(pd.ExcelFile, "parse", parser)
+
+        expected_defaults = {
+            "xlsx": "openpyxl",
+            "xlsm": "openpyxl",
+            "xlsb": "pyxlsb",
+            "xls": "xlrd",
+            "ods": "odf",
+        }
+
+        with open("test1" + read_ext, "rb") as f:
+            result = pd.read_excel(f)
+
+        if engine is not None:
+            expected = engine
+        else:
+            expected = expected_defaults[read_ext[1:]]
+        assert result == expected
+
+    def test_usecols_int(self, read_ext):
+        # usecols as int
+        msg = "Passing an integer for `usecols`"
+        with pytest.raises(ValueError, match=msg):
+            pd.read_excel(
+                "test1" + read_ext, sheet_name="Sheet1", index_col=0, usecols=3
+            )
+
+        # usecols as int
+        with pytest.raises(ValueError, match=msg):
+            pd.read_excel(
+                "test1" + read_ext,
+                sheet_name="Sheet2",
+                skiprows=[1],
+                index_col=0,
+                usecols=3,
+            )
+
+    def test_usecols_list(self, request, read_ext, df_ref):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        df_ref = df_ref.reindex(columns=["B", "C"])
+        df1 = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet1", index_col=0, usecols=[0, 2, 3]
+        )
+        df2 = pd.read_excel(
+            "test1" + read_ext,
+            sheet_name="Sheet2",
+            skiprows=[1],
+            index_col=0,
+            usecols=[0, 2, 3],
+        )
+
+        # TODO add index to xls file)
+        tm.assert_frame_equal(df1, df_ref, check_names=False)
+        tm.assert_frame_equal(df2, df_ref, check_names=False)
+
+    def test_usecols_str(self, request, read_ext, df_ref):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        df1 = df_ref.reindex(columns=["A", "B", "C"])
+        df2 = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet1", index_col=0, usecols="A:D"
+        )
+        df3 = pd.read_excel(
+            "test1" + read_ext,
+            sheet_name="Sheet2",
+            skiprows=[1],
+            index_col=0,
+            usecols="A:D",
+        )
+
+        # TODO add index to xls, read xls ignores index name ?
+        tm.assert_frame_equal(df2, df1, check_names=False)
+        tm.assert_frame_equal(df3, df1, check_names=False)
+
+        df1 = df_ref.reindex(columns=["B", "C"])
+        df2 = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet1", index_col=0, usecols="A,C,D"
+        )
+        df3 = pd.read_excel(
+            "test1" + read_ext,
+            sheet_name="Sheet2",
+            skiprows=[1],
+            index_col=0,
+            usecols="A,C,D",
+        )
+        # TODO add index to xls file
+        tm.assert_frame_equal(df2, df1, check_names=False)
+        tm.assert_frame_equal(df3, df1, check_names=False)
+
+        df1 = df_ref.reindex(columns=["B", "C"])
+        df2 = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet1", index_col=0, usecols="A,C:D"
+        )
+        df3 = pd.read_excel(
+            "test1" + read_ext,
+            sheet_name="Sheet2",
+            skiprows=[1],
+            index_col=0,
+            usecols="A,C:D",
+        )
+        tm.assert_frame_equal(df2, df1, check_names=False)
+        tm.assert_frame_equal(df3, df1, check_names=False)
+
+    @pytest.mark.parametrize(
+        "usecols", [[0, 1, 3], [0, 3, 1], [1, 0, 3], [1, 3, 0], [3, 0, 1], [3, 1, 0]]
+    )
+    def test_usecols_diff_positional_int_columns_order(
+        self, request, read_ext, usecols, df_ref
+    ):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        expected = df_ref[["A", "C"]]
+        result = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet1", index_col=0, usecols=usecols
+        )
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.parametrize("usecols", [["B", "D"], ["D", "B"]])
+    def test_usecols_diff_positional_str_columns_order(self, read_ext, usecols, df_ref):
+        expected = df_ref[["B", "D"]]
+        expected.index = range(len(expected))
+
+        result = pd.read_excel("test1" + read_ext, sheet_name="Sheet1", usecols=usecols)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    def test_read_excel_without_slicing(self, request, read_ext, df_ref):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        expected = df_ref
+        result = pd.read_excel("test1" + read_ext, sheet_name="Sheet1", index_col=0)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    def test_usecols_excel_range_str(self, request, read_ext, df_ref):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        expected = df_ref[["C", "D"]]
+        result = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet1", index_col=0, usecols="A,D:E"
+        )
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    def test_usecols_excel_range_str_invalid(self, read_ext):
+        msg = "Invalid column name: E1"
+
+        with pytest.raises(ValueError, match=msg):
+            pd.read_excel("test1" + read_ext, sheet_name="Sheet1", usecols="D:E1")
+
+    def test_index_col_label_error(self, read_ext):
+        msg = "list indices must be integers.*, not str"
+
+        with pytest.raises(TypeError, match=msg):
+            pd.read_excel(
+                "test1" + read_ext,
+                sheet_name="Sheet1",
+                index_col=["A"],
+                usecols=["A", "C"],
+            )
+
+    def test_index_col_empty(self, read_ext):
+        # see gh-9208
+        result = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet3", index_col=["A", "B", "C"]
+        )
+        expected = DataFrame(
+            columns=["D", "E", "F"],
+            index=MultiIndex(levels=[[]] * 3, codes=[[]] * 3, names=["A", "B", "C"]),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("index_col", [None, 2])
+    def test_index_col_with_unnamed(self, read_ext, index_col):
+        # see gh-18792
+        result = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet4", index_col=index_col
+        )
+        expected = DataFrame(
+            [["i1", "a", "x"], ["i2", "b", "y"]], columns=["Unnamed: 0", "col1", "col2"]
+        )
+        if index_col:
+            expected = expected.set_index(expected.columns[index_col])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_usecols_pass_non_existent_column(self, read_ext):
+        msg = (
+            "Usecols do not match columns, "
+            "columns expected but not found: " + r"\['E'\]"
+        )
+
+        with pytest.raises(ValueError, match=msg):
+            pd.read_excel("test1" + read_ext, usecols=["E"])
+
+    def test_usecols_wrong_type(self, read_ext):
+        msg = (
+            "'usecols' must either be list-like of "
+            "all strings, all unicode, all integers or a callable."
+        )
+
+        with pytest.raises(ValueError, match=msg):
+            pd.read_excel("test1" + read_ext, usecols=["E1", 0])
+
+    def test_excel_stop_iterator(self, read_ext):
+        parsed = pd.read_excel("test2" + read_ext, sheet_name="Sheet1")
+        expected = DataFrame([["aaaa", "bbbbb"]], columns=["Test", "Test1"])
+        tm.assert_frame_equal(parsed, expected)
+
+    def test_excel_cell_error_na(self, request, read_ext):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        parsed = pd.read_excel("test3" + read_ext, sheet_name="Sheet1")
+        expected = DataFrame([[np.nan]], columns=["Test"])
+        tm.assert_frame_equal(parsed, expected)
+
+    def test_excel_table(self, request, read_ext, df_ref):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        df1 = pd.read_excel("test1" + read_ext, sheet_name="Sheet1", index_col=0)
+        df2 = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet2", skiprows=[1], index_col=0
+        )
+        # TODO add index to file
+        tm.assert_frame_equal(df1, df_ref, check_names=False)
+        tm.assert_frame_equal(df2, df_ref, check_names=False)
+
+        df3 = pd.read_excel(
+            "test1" + read_ext, sheet_name="Sheet1", index_col=0, skipfooter=1
+        )
+        tm.assert_frame_equal(df3, df1.iloc[:-1])
+
+    def test_reader_special_dtypes(self, request, read_ext):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        expected = DataFrame.from_dict(
+            {
+                "IntCol": [1, 2, -3, 4, 0],
+                "FloatCol": [1.25, 2.25, 1.83, 1.92, 0.0000000005],
+                "BoolCol": [True, False, True, True, False],
+                "StrCol": [1, 2, 3, 4, 5],
+                "Str2Col": ["a", 3, "c", "d", "e"],
+                "DateCol": [
+                    datetime(2013, 10, 30),
+                    datetime(2013, 10, 31),
+                    datetime(1905, 1, 1),
+                    datetime(2013, 12, 14),
+                    datetime(2015, 3, 14),
+                ],
+            },
+        )
+        basename = "test_types"
+
+        # should read in correctly and infer types
+        actual = pd.read_excel(basename + read_ext, sheet_name="Sheet1")
+        tm.assert_frame_equal(actual, expected)
+
+        # if not coercing number, then int comes in as float
+        float_expected = expected.copy()
+        float_expected.loc[float_expected.index[1], "Str2Col"] = 3.0
+        actual = pd.read_excel(basename + read_ext, sheet_name="Sheet1")
+        tm.assert_frame_equal(actual, float_expected)
+
+        # check setting Index (assuming xls and xlsx are the same here)
+        for icol, name in enumerate(expected.columns):
+            actual = pd.read_excel(
+                basename + read_ext, sheet_name="Sheet1", index_col=icol
+            )
+            exp = expected.set_index(name)
+            tm.assert_frame_equal(actual, exp)
+
+        expected["StrCol"] = expected["StrCol"].apply(str)
+        actual = pd.read_excel(
+            basename + read_ext, sheet_name="Sheet1", converters={"StrCol": str}
+        )
+        tm.assert_frame_equal(actual, expected)
+
+    # GH8212 - support for converters and missing values
+    def test_reader_converters(self, read_ext):
+        basename = "test_converters"
+
+        expected = DataFrame.from_dict(
+            {
+                "IntCol": [1, 2, -3, -1000, 0],
+                "FloatCol": [12.5, np.nan, 18.3, 19.2, 0.000000005],
+                "BoolCol": ["Found", "Found", "Found", "Not found", "Found"],
+                "StrCol": ["1", np.nan, "3", "4", "5"],
+            }
+        )
+
+        converters = {
+            "IntCol": lambda x: int(x) if x != "" else -1000,
+            "FloatCol": lambda x: 10 * x if x else np.nan,
+            2: lambda x: "Found" if x != "" else "Not found",
+            3: lambda x: str(x) if x else "",
+        }
+
+        # should read in correctly and set types of single cells (not array
+        # dtypes)
+        actual = pd.read_excel(
+            basename + read_ext, sheet_name="Sheet1", converters=converters
+        )
+        tm.assert_frame_equal(actual, expected)
+
+    def test_reader_dtype(self, read_ext):
+        # GH 8212
+        basename = "testdtype"
+        actual = pd.read_excel(basename + read_ext)
+
+        expected = DataFrame(
+            {
+                "a": [1, 2, 3, 4],
+                "b": [2.5, 3.5, 4.5, 5.5],
+                "c": [1, 2, 3, 4],
+                "d": [1.0, 2.0, np.nan, 4.0],
+            }
+        ).reindex(columns=["a", "b", "c", "d"])
+
+        tm.assert_frame_equal(actual, expected)
+
+        actual = pd.read_excel(
+            basename + read_ext, dtype={"a": "float64", "b": "float32", "c": str}
+        )
+
+        expected["a"] = expected["a"].astype("float64")
+        expected["b"] = expected["b"].astype("float32")
+        expected["c"] = ["001", "002", "003", "004"]
+        tm.assert_frame_equal(actual, expected)
+
+        msg = "Unable to convert column d to type int64"
+        with pytest.raises(ValueError, match=msg):
+            pd.read_excel(basename + read_ext, dtype={"d": "int64"})
+
+    @pytest.mark.parametrize(
+        "dtype,expected",
+        [
+            (
+                None,
+                DataFrame(
+                    {
+                        "a": [1, 2, 3, 4],
+                        "b": [2.5, 3.5, 4.5, 5.5],
+                        "c": [1, 2, 3, 4],
+                        "d": [1.0, 2.0, np.nan, 4.0],
+                    }
+                ),
+            ),
+            (
+                {"a": "float64", "b": "float32", "c": str, "d": str},
+                DataFrame(
+                    {
+                        "a": Series([1, 2, 3, 4], dtype="float64"),
+                        "b": Series([2.5, 3.5, 4.5, 5.5], dtype="float32"),
+                        "c": ["001", "002", "003", "004"],
+                        "d": ["1", "2", np.nan, "4"],
+                    }
+                ),
+            ),
+        ],
+    )
+    def test_reader_dtype_str(self, read_ext, dtype, expected):
+        # see gh-20377
+        basename = "testdtype"
+
+        actual = pd.read_excel(basename + read_ext, dtype=dtype)
+        tm.assert_frame_equal(actual, expected)
+
+    def test_dtype_backend(self, read_ext, dtype_backend):
+        # GH#36712
+        if read_ext in (".xlsb", ".xls"):
+            pytest.skip(f"No engine for filetype: '{read_ext}'")
+
+        df = DataFrame(
+            {
+                "a": Series([1, 3], dtype="Int64"),
+                "b": Series([2.5, 4.5], dtype="Float64"),
+                "c": Series([True, False], dtype="boolean"),
+                "d": Series(["a", "b"], dtype="string"),
+                "e": Series([pd.NA, 6], dtype="Int64"),
+                "f": Series([pd.NA, 7.5], dtype="Float64"),
+                "g": Series([pd.NA, True], dtype="boolean"),
+                "h": Series([pd.NA, "a"], dtype="string"),
+                "i": Series([pd.Timestamp("2019-12-31")] * 2),
+                "j": Series([pd.NA, pd.NA], dtype="Int64"),
+            }
+        )
+        with tm.ensure_clean(read_ext) as file_path:
+            df.to_excel(file_path, "test", index=False)
+            result = pd.read_excel(
+                file_path, sheet_name="test", dtype_backend=dtype_backend
+            )
+        if dtype_backend == "pyarrow":
+            import pyarrow as pa
+
+            from pandas.arrays import ArrowExtensionArray
+
+            expected = DataFrame(
+                {
+                    col: ArrowExtensionArray(pa.array(df[col], from_pandas=True))
+                    for col in df.columns
+                }
+            )
+            # pyarrow by default infers timestamp resolution as us, not ns
+            expected["i"] = ArrowExtensionArray(
+                expected["i"].array._data.cast(pa.timestamp(unit="us"))
+            )
+            # pyarrow supports a null type, so don't have to default to Int64
+            expected["j"] = ArrowExtensionArray(pa.array([None, None]))
+        else:
+            expected = df
+        tm.assert_frame_equal(result, expected)
+
+    def test_dtype_backend_and_dtype(self, read_ext):
+        # GH#36712
+        if read_ext in (".xlsb", ".xls"):
+            pytest.skip(f"No engine for filetype: '{read_ext}'")
+
+        df = DataFrame({"a": [np.nan, 1.0], "b": [2.5, np.nan]})
+        with tm.ensure_clean(read_ext) as file_path:
+            df.to_excel(file_path, "test", index=False)
+            result = pd.read_excel(
+                file_path,
+                sheet_name="test",
+                dtype_backend="numpy_nullable",
+                dtype="float64",
+            )
+        tm.assert_frame_equal(result, df)
+
+    @td.skip_if_no("pyarrow")
+    def test_dtype_backend_string(self, read_ext, string_storage):
+        # GH#36712
+        if read_ext in (".xlsb", ".xls"):
+            pytest.skip(f"No engine for filetype: '{read_ext}'")
+
+        import pyarrow as pa
+
+        with pd.option_context("mode.string_storage", string_storage):
+            df = DataFrame(
+                {
+                    "a": np.array(["a", "b"], dtype=np.object_),
+                    "b": np.array(["x", pd.NA], dtype=np.object_),
+                }
+            )
+            with tm.ensure_clean(read_ext) as file_path:
+                df.to_excel(file_path, "test", index=False)
+                result = pd.read_excel(
+                    file_path, sheet_name="test", dtype_backend="numpy_nullable"
+                )
+
+            if string_storage == "python":
+                expected = DataFrame(
+                    {
+                        "a": StringArray(np.array(["a", "b"], dtype=np.object_)),
+                        "b": StringArray(np.array(["x", pd.NA], dtype=np.object_)),
+                    }
+                )
+            else:
+                expected = DataFrame(
+                    {
+                        "a": ArrowStringArray(pa.array(["a", "b"])),
+                        "b": ArrowStringArray(pa.array(["x", None])),
+                    }
+                )
+            tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtypes, exp_value", [({}, "1"), ({"a.1": "int64"}, 1)])
+    def test_dtype_mangle_dup_cols(self, read_ext, dtypes, exp_value):
+        # GH#35211
+        basename = "df_mangle_dup_col_dtypes"
+        dtype_dict = {"a": str, **dtypes}
+        dtype_dict_copy = dtype_dict.copy()
+        # GH#42462
+        result = pd.read_excel(basename + read_ext, 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)
+
+    def test_reader_spaces(self, read_ext):
+        # see gh-32207
+        basename = "test_spaces"
+
+        actual = pd.read_excel(basename + read_ext)
+        expected = DataFrame(
+            {
+                "testcol": [
+                    "this is great",
+                    "4    spaces",
+                    "1 trailing ",
+                    " 1 leading",
+                    "2  spaces  multiple  times",
+                ]
+            }
+        )
+        tm.assert_frame_equal(actual, expected)
+
+    # gh-36122, gh-35802
+    @pytest.mark.parametrize(
+        "basename,expected",
+        [
+            ("gh-35802", DataFrame({"COLUMN": ["Test (1)"]})),
+            ("gh-36122", DataFrame(columns=["got 2nd sa"])),
+        ],
+    )
+    def test_read_excel_ods_nested_xml(self, engine, read_ext, basename, expected):
+        # see gh-35802
+        if engine != "odf":
+            pytest.skip(f"Skipped for engine: {engine}")
+
+        actual = pd.read_excel(basename + read_ext)
+        tm.assert_frame_equal(actual, expected)
+
+    def test_reading_all_sheets(self, read_ext):
+        # Test reading all sheet names by setting sheet_name to None,
+        # Ensure a dict is returned.
+        # See PR #9450
+        basename = "test_multisheet"
+        dfs = pd.read_excel(basename + read_ext, sheet_name=None)
+        # ensure this is not alphabetical to test order preservation
+        expected_keys = ["Charlie", "Alpha", "Beta"]
+        tm.assert_contains_all(expected_keys, dfs.keys())
+        # Issue 9930
+        # Ensure sheet order is preserved
+        assert expected_keys == list(dfs.keys())
+
+    def test_reading_multiple_specific_sheets(self, read_ext):
+        # Test reading specific sheet names by specifying a mixed list
+        # of integers and strings, and confirm that duplicated sheet
+        # references (positions/names) are removed properly.
+        # Ensure a dict is returned
+        # See PR #9450
+        basename = "test_multisheet"
+        # Explicitly request duplicates. Only the set should be returned.
+        expected_keys = [2, "Charlie", "Charlie"]
+        dfs = pd.read_excel(basename + read_ext, sheet_name=expected_keys)
+        expected_keys = list(set(expected_keys))
+        tm.assert_contains_all(expected_keys, dfs.keys())
+        assert len(expected_keys) == len(dfs.keys())
+
+    def test_reading_all_sheets_with_blank(self, read_ext):
+        # Test reading all sheet names by setting sheet_name to None,
+        # In the case where some sheets are blank.
+        # Issue #11711
+        basename = "blank_with_header"
+        dfs = pd.read_excel(basename + read_ext, sheet_name=None)
+        expected_keys = ["Sheet1", "Sheet2", "Sheet3"]
+        tm.assert_contains_all(expected_keys, dfs.keys())
+
+    # GH6403
+    def test_read_excel_blank(self, read_ext):
+        actual = pd.read_excel("blank" + read_ext, sheet_name="Sheet1")
+        tm.assert_frame_equal(actual, DataFrame())
+
+    def test_read_excel_blank_with_header(self, read_ext):
+        expected = DataFrame(columns=["col_1", "col_2"])
+        actual = pd.read_excel("blank_with_header" + read_ext, sheet_name="Sheet1")
+        tm.assert_frame_equal(actual, expected)
+
+    def test_exception_message_includes_sheet_name(self, read_ext):
+        # GH 48706
+        with pytest.raises(ValueError, match=r" \(sheet: Sheet1\)$"):
+            pd.read_excel("blank_with_header" + read_ext, header=[1], sheet_name=None)
+        with pytest.raises(ZeroDivisionError, match=r" \(sheet: Sheet1\)$"):
+            pd.read_excel("test1" + read_ext, usecols=lambda x: 1 / 0, sheet_name=None)
+
+    @pytest.mark.filterwarnings("ignore:Cell A4 is marked:UserWarning:openpyxl")
+    def test_date_conversion_overflow(self, request, engine, read_ext):
+        # GH 10001 : pandas.ExcelFile ignore parse_dates=False
+        if engine == "pyxlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        expected = DataFrame(
+            [
+                [pd.Timestamp("2016-03-12"), "Marc Johnson"],
+                [pd.Timestamp("2016-03-16"), "Jack Black"],
+                [1e20, "Timothy Brown"],
+            ],
+            columns=["DateColWithBigInt", "StringCol"],
+        )
+
+        if engine == "openpyxl":
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Maybe not supported by openpyxl")
+            )
+
+        if engine is None and read_ext in (".xlsx", ".xlsm"):
+            # GH 35029
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Defaults to openpyxl, maybe not supported")
+            )
+
+        result = pd.read_excel("testdateoverflow" + read_ext)
+        tm.assert_frame_equal(result, expected)
+
+    def test_sheet_name(self, request, read_ext, df_ref):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+        filename = "test1"
+        sheet_name = "Sheet1"
+
+        df1 = pd.read_excel(
+            filename + read_ext, sheet_name=sheet_name, index_col=0
+        )  # doc
+        df2 = pd.read_excel(filename + read_ext, index_col=0, sheet_name=sheet_name)
+
+        tm.assert_frame_equal(df1, df_ref, check_names=False)
+        tm.assert_frame_equal(df2, df_ref, check_names=False)
+
+    def test_excel_read_buffer(self, read_ext):
+        pth = "test1" + read_ext
+        expected = pd.read_excel(pth, sheet_name="Sheet1", index_col=0)
+        with open(pth, "rb") as f:
+            actual = pd.read_excel(f, sheet_name="Sheet1", index_col=0)
+            tm.assert_frame_equal(expected, actual)
+
+    def test_bad_engine_raises(self):
+        bad_engine = "foo"
+        with pytest.raises(ValueError, match="Unknown engine: foo"):
+            pd.read_excel("", engine=bad_engine)
+
+    @pytest.mark.parametrize(
+        "sheet_name",
+        [3, [0, 3], [3, 0], "Sheet4", ["Sheet1", "Sheet4"], ["Sheet4", "Sheet1"]],
+    )
+    def test_bad_sheetname_raises(self, read_ext, sheet_name):
+        # GH 39250
+        msg = "Worksheet index 3 is invalid|Worksheet named 'Sheet4' not found"
+        with pytest.raises(ValueError, match=msg):
+            pd.read_excel("blank" + read_ext, sheet_name=sheet_name)
+
+    def test_missing_file_raises(self, read_ext):
+        bad_file = f"foo{read_ext}"
+        # CI tests with other languages, translates to "No such file or directory"
+        match = r"(No such file or directory|没有那个文件或目录|File o directory non esistente)"
+        with pytest.raises(FileNotFoundError, match=match):
+            pd.read_excel(bad_file)
+
+    def test_corrupt_bytes_raises(self, engine):
+        bad_stream = b"foo"
+        if engine is None:
+            error = ValueError
+            msg = (
+                "Excel file format cannot be determined, you must "
+                "specify an engine manually."
+            )
+        elif engine == "xlrd":
+            from xlrd import XLRDError
+
+            error = XLRDError
+            msg = (
+                "Unsupported format, or corrupt file: Expected BOF "
+                "record; found b'foo'"
+            )
+        else:
+            error = BadZipFile
+            msg = "File is not a zip file"
+        with pytest.raises(error, match=msg):
+            pd.read_excel(bad_stream)
+
+    @pytest.mark.network
+    @tm.network(
+        url=(
+            "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
+            "pandas/tests/io/data/excel/test1.xlsx"
+        ),
+        check_before_test=True,
+    )
+    def test_read_from_http_url(self, read_ext):
+        url = (
+            "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
+            "pandas/tests/io/data/excel/test1" + read_ext
+        )
+        url_table = pd.read_excel(url)
+        local_table = pd.read_excel("test1" + read_ext)
+        tm.assert_frame_equal(url_table, local_table)
+
+    @td.skip_if_not_us_locale
+    @pytest.mark.single_cpu
+    def test_read_from_s3_url(self, read_ext, s3_resource, s3so):
+        # Bucket "pandas-test" created in tests/io/conftest.py
+        with open("test1" + read_ext, "rb") as f:
+            s3_resource.Bucket("pandas-test").put_object(Key="test1" + read_ext, Body=f)
+
+        url = "s3://pandas-test/test1" + read_ext
+
+        url_table = pd.read_excel(url, storage_options=s3so)
+        local_table = pd.read_excel("test1" + read_ext)
+        tm.assert_frame_equal(url_table, local_table)
+
+    @pytest.mark.single_cpu
+    def test_read_from_s3_object(self, read_ext, s3_resource, s3so):
+        # GH 38788
+        # Bucket "pandas-test" created in tests/io/conftest.py
+        with open("test1" + read_ext, "rb") as f:
+            s3_resource.Bucket("pandas-test").put_object(Key="test1" + read_ext, Body=f)
+
+        import s3fs
+
+        s3 = s3fs.S3FileSystem(**s3so)
+
+        with s3.open("s3://pandas-test/test1" + read_ext) as f:
+            url_table = pd.read_excel(f)
+
+        local_table = pd.read_excel("test1" + read_ext)
+        tm.assert_frame_equal(url_table, local_table)
+
+    @pytest.mark.slow
+    def test_read_from_file_url(self, read_ext, datapath):
+        # FILE
+        localtable = os.path.join(datapath("io", "data", "excel"), "test1" + read_ext)
+        local_table = pd.read_excel(localtable)
+
+        try:
+            url_table = pd.read_excel("file://localhost/" + localtable)
+        except URLError:
+            # fails on some systems
+            platform_info = " ".join(platform.uname()).strip()
+            pytest.skip(f"failing on {platform_info}")
+
+        tm.assert_frame_equal(url_table, local_table)
+
+    def test_read_from_pathlib_path(self, read_ext):
+        # GH12655
+        str_path = "test1" + read_ext
+        expected = pd.read_excel(str_path, sheet_name="Sheet1", index_col=0)
+
+        path_obj = Path("test1" + read_ext)
+        actual = pd.read_excel(path_obj, sheet_name="Sheet1", index_col=0)
+
+        tm.assert_frame_equal(expected, actual)
+
+    @td.skip_if_no("py.path")
+    def test_read_from_py_localpath(self, read_ext):
+        # GH12655
+        from py.path import local as LocalPath
+
+        str_path = os.path.join("test1" + read_ext)
+        expected = pd.read_excel(str_path, sheet_name="Sheet1", index_col=0)
+
+        path_obj = LocalPath().join("test1" + read_ext)
+        actual = pd.read_excel(path_obj, sheet_name="Sheet1", index_col=0)
+
+        tm.assert_frame_equal(expected, actual)
+
+    def test_close_from_py_localpath(self, read_ext):
+        # GH31467
+        str_path = os.path.join("test1" + read_ext)
+        with open(str_path, "rb") as f:
+            x = pd.read_excel(f, sheet_name="Sheet1", index_col=0)
+            del x
+            # should not throw an exception because the passed file was closed
+            f.read()
+
+    def test_reader_seconds(self, request, engine, read_ext):
+        if engine == "pyxlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        # Test reading times with and without milliseconds. GH5945.
+        expected = DataFrame.from_dict(
+            {
+                "Time": [
+                    time(1, 2, 3),
+                    time(2, 45, 56, 100000),
+                    time(4, 29, 49, 200000),
+                    time(6, 13, 42, 300000),
+                    time(7, 57, 35, 400000),
+                    time(9, 41, 28, 500000),
+                    time(11, 25, 21, 600000),
+                    time(13, 9, 14, 700000),
+                    time(14, 53, 7, 800000),
+                    time(16, 37, 0, 900000),
+                    time(18, 20, 54),
+                ]
+            }
+        )
+
+        actual = pd.read_excel("times_1900" + read_ext, sheet_name="Sheet1")
+        tm.assert_frame_equal(actual, expected)
+
+        actual = pd.read_excel("times_1904" + read_ext, sheet_name="Sheet1")
+        tm.assert_frame_equal(actual, expected)
+
+    def test_read_excel_multiindex(self, request, read_ext):
+        # see gh-4679
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        mi = MultiIndex.from_product([["foo", "bar"], ["a", "b"]])
+        mi_file = "testmultiindex" + read_ext
+
+        # "mi_column" sheet
+        expected = DataFrame(
+            [
+                [1, 2.5, pd.Timestamp("2015-01-01"), True],
+                [2, 3.5, pd.Timestamp("2015-01-02"), False],
+                [3, 4.5, pd.Timestamp("2015-01-03"), False],
+                [4, 5.5, pd.Timestamp("2015-01-04"), True],
+            ],
+            columns=mi,
+        )
+
+        actual = pd.read_excel(
+            mi_file, sheet_name="mi_column", header=[0, 1], index_col=0
+        )
+        tm.assert_frame_equal(actual, expected)
+
+        # "mi_index" sheet
+        expected.index = mi
+        expected.columns = ["a", "b", "c", "d"]
+
+        actual = pd.read_excel(mi_file, sheet_name="mi_index", index_col=[0, 1])
+        tm.assert_frame_equal(actual, expected, check_names=False)
+
+        # "both" sheet
+        expected.columns = mi
+
+        actual = pd.read_excel(
+            mi_file, sheet_name="both", index_col=[0, 1], header=[0, 1]
+        )
+        tm.assert_frame_equal(actual, expected, check_names=False)
+
+        # "mi_index_name" sheet
+        expected.columns = ["a", "b", "c", "d"]
+        expected.index = mi.set_names(["ilvl1", "ilvl2"])
+
+        actual = pd.read_excel(mi_file, sheet_name="mi_index_name", index_col=[0, 1])
+        tm.assert_frame_equal(actual, expected)
+
+        # "mi_column_name" sheet
+        expected.index = list(range(4))
+        expected.columns = mi.set_names(["c1", "c2"])
+        actual = pd.read_excel(
+            mi_file, sheet_name="mi_column_name", header=[0, 1], index_col=0
+        )
+        tm.assert_frame_equal(actual, expected)
+
+        # see gh-11317
+        # "name_with_int" sheet
+        expected.columns = mi.set_levels([1, 2], level=1).set_names(["c1", "c2"])
+
+        actual = pd.read_excel(
+            mi_file, sheet_name="name_with_int", index_col=0, header=[0, 1]
+        )
+        tm.assert_frame_equal(actual, expected)
+
+        # "both_name" sheet
+        expected.columns = mi.set_names(["c1", "c2"])
+        expected.index = mi.set_names(["ilvl1", "ilvl2"])
+
+        actual = pd.read_excel(
+            mi_file, sheet_name="both_name", index_col=[0, 1], header=[0, 1]
+        )
+        tm.assert_frame_equal(actual, expected)
+
+        # "both_skiprows" sheet
+        actual = pd.read_excel(
+            mi_file,
+            sheet_name="both_name_skiprows",
+            index_col=[0, 1],
+            header=[0, 1],
+            skiprows=2,
+        )
+        tm.assert_frame_equal(actual, expected)
+
+    @pytest.mark.parametrize(
+        "sheet_name,idx_lvl2",
+        [
+            ("both_name_blank_after_mi_name", [np.nan, "b", "a", "b"]),
+            ("both_name_multiple_blanks", [np.nan] * 4),
+        ],
+    )
+    def test_read_excel_multiindex_blank_after_name(
+        self, request, read_ext, sheet_name, idx_lvl2
+    ):
+        # GH34673
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb (GH4679"
+                )
+            )
+
+        mi_file = "testmultiindex" + read_ext
+        mi = MultiIndex.from_product([["foo", "bar"], ["a", "b"]], names=["c1", "c2"])
+        expected = DataFrame(
+            [
+                [1, 2.5, pd.Timestamp("2015-01-01"), True],
+                [2, 3.5, pd.Timestamp("2015-01-02"), False],
+                [3, 4.5, pd.Timestamp("2015-01-03"), False],
+                [4, 5.5, pd.Timestamp("2015-01-04"), True],
+            ],
+            columns=mi,
+            index=MultiIndex.from_arrays(
+                (["foo", "foo", "bar", "bar"], idx_lvl2),
+                names=["ilvl1", "ilvl2"],
+            ),
+        )
+        result = pd.read_excel(
+            mi_file,
+            sheet_name=sheet_name,
+            index_col=[0, 1],
+            header=[0, 1],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_read_excel_multiindex_header_only(self, read_ext):
+        # see gh-11733.
+        #
+        # Don't try to parse a header name if there isn't one.
+        mi_file = "testmultiindex" + read_ext
+        result = pd.read_excel(mi_file, sheet_name="index_col_none", header=[0, 1])
+
+        exp_columns = MultiIndex.from_product([("A", "B"), ("key", "val")])
+        expected = DataFrame([[1, 2, 3, 4]] * 2, columns=exp_columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_excel_old_index_format(self, read_ext):
+        # see gh-4679
+        filename = "test_index_name_pre17" + read_ext
+
+        # We detect headers to determine if index names exist, so
+        # that "index" name in the "names" version of the data will
+        # now be interpreted as rows that include null data.
+        data = np.array(
+            [
+                [None, None, None, None, None],
+                ["R0C0", "R0C1", "R0C2", "R0C3", "R0C4"],
+                ["R1C0", "R1C1", "R1C2", "R1C3", "R1C4"],
+                ["R2C0", "R2C1", "R2C2", "R2C3", "R2C4"],
+                ["R3C0", "R3C1", "R3C2", "R3C3", "R3C4"],
+                ["R4C0", "R4C1", "R4C2", "R4C3", "R4C4"],
+            ]
+        )
+        columns = ["C_l0_g0", "C_l0_g1", "C_l0_g2", "C_l0_g3", "C_l0_g4"]
+        mi = MultiIndex(
+            levels=[
+                ["R0", "R_l0_g0", "R_l0_g1", "R_l0_g2", "R_l0_g3", "R_l0_g4"],
+                ["R1", "R_l1_g0", "R_l1_g1", "R_l1_g2", "R_l1_g3", "R_l1_g4"],
+            ],
+            codes=[[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]],
+            names=[None, None],
+        )
+        si = Index(
+            ["R0", "R_l0_g0", "R_l0_g1", "R_l0_g2", "R_l0_g3", "R_l0_g4"], name=None
+        )
+
+        expected = DataFrame(data, index=si, columns=columns)
+
+        actual = pd.read_excel(filename, sheet_name="single_names", index_col=0)
+        tm.assert_frame_equal(actual, expected)
+
+        expected.index = mi
+
+        actual = pd.read_excel(filename, sheet_name="multi_names", index_col=[0, 1])
+        tm.assert_frame_equal(actual, expected)
+
+        # The analogous versions of the "names" version data
+        # where there are explicitly no names for the indices.
+        data = np.array(
+            [
+                ["R0C0", "R0C1", "R0C2", "R0C3", "R0C4"],
+                ["R1C0", "R1C1", "R1C2", "R1C3", "R1C4"],
+                ["R2C0", "R2C1", "R2C2", "R2C3", "R2C4"],
+                ["R3C0", "R3C1", "R3C2", "R3C3", "R3C4"],
+                ["R4C0", "R4C1", "R4C2", "R4C3", "R4C4"],
+            ]
+        )
+        columns = ["C_l0_g0", "C_l0_g1", "C_l0_g2", "C_l0_g3", "C_l0_g4"]
+        mi = MultiIndex(
+            levels=[
+                ["R_l0_g0", "R_l0_g1", "R_l0_g2", "R_l0_g3", "R_l0_g4"],
+                ["R_l1_g0", "R_l1_g1", "R_l1_g2", "R_l1_g3", "R_l1_g4"],
+            ],
+            codes=[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4]],
+            names=[None, None],
+        )
+        si = Index(["R_l0_g0", "R_l0_g1", "R_l0_g2", "R_l0_g3", "R_l0_g4"], name=None)
+
+        expected = DataFrame(data, index=si, columns=columns)
+
+        actual = pd.read_excel(filename, sheet_name="single_no_names", index_col=0)
+        tm.assert_frame_equal(actual, expected)
+
+        expected.index = mi
+
+        actual = pd.read_excel(filename, sheet_name="multi_no_names", index_col=[0, 1])
+        tm.assert_frame_equal(actual, expected, check_names=False)
+
+    def test_read_excel_bool_header_arg(self, read_ext):
+        # GH 6114
+        msg = "Passing a bool to header is invalid"
+        for arg in [True, False]:
+            with pytest.raises(TypeError, match=msg):
+                pd.read_excel("test1" + read_ext, header=arg)
+
+    def test_read_excel_skiprows(self, request, read_ext):
+        # GH 4903
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        actual = pd.read_excel(
+            "testskiprows" + read_ext, sheet_name="skiprows_list", skiprows=[0, 2]
+        )
+        expected = DataFrame(
+            [
+                [1, 2.5, pd.Timestamp("2015-01-01"), True],
+                [2, 3.5, pd.Timestamp("2015-01-02"), False],
+                [3, 4.5, pd.Timestamp("2015-01-03"), False],
+                [4, 5.5, pd.Timestamp("2015-01-04"), True],
+            ],
+            columns=["a", "b", "c", "d"],
+        )
+        tm.assert_frame_equal(actual, expected)
+
+        actual = pd.read_excel(
+            "testskiprows" + read_ext,
+            sheet_name="skiprows_list",
+            skiprows=np.array([0, 2]),
+        )
+        tm.assert_frame_equal(actual, expected)
+
+        # GH36435
+        actual = pd.read_excel(
+            "testskiprows" + read_ext,
+            sheet_name="skiprows_list",
+            skiprows=lambda x: x in [0, 2],
+        )
+        tm.assert_frame_equal(actual, expected)
+
+        actual = pd.read_excel(
+            "testskiprows" + read_ext,
+            sheet_name="skiprows_list",
+            skiprows=3,
+            names=["a", "b", "c", "d"],
+        )
+        expected = DataFrame(
+            [
+                # [1, 2.5, pd.Timestamp("2015-01-01"), True],
+                [2, 3.5, pd.Timestamp("2015-01-02"), False],
+                [3, 4.5, pd.Timestamp("2015-01-03"), False],
+                [4, 5.5, pd.Timestamp("2015-01-04"), True],
+            ],
+            columns=["a", "b", "c", "d"],
+        )
+        tm.assert_frame_equal(actual, expected)
+
+    def test_read_excel_skiprows_callable_not_in(self, request, read_ext):
+        # GH 4903
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        actual = pd.read_excel(
+            "testskiprows" + read_ext,
+            sheet_name="skiprows_list",
+            skiprows=lambda x: x not in [1, 3, 5],
+        )
+        expected = DataFrame(
+            [
+                [1, 2.5, pd.Timestamp("2015-01-01"), True],
+                # [2, 3.5, pd.Timestamp("2015-01-02"), False],
+                [3, 4.5, pd.Timestamp("2015-01-03"), False],
+                # [4, 5.5, pd.Timestamp("2015-01-04"), True],
+            ],
+            columns=["a", "b", "c", "d"],
+        )
+        tm.assert_frame_equal(actual, expected)
+
+    def test_read_excel_nrows(self, read_ext):
+        # GH 16645
+        num_rows_to_pull = 5
+        actual = pd.read_excel("test1" + read_ext, nrows=num_rows_to_pull)
+        expected = pd.read_excel("test1" + read_ext)
+        expected = expected[:num_rows_to_pull]
+        tm.assert_frame_equal(actual, expected)
+
+    def test_read_excel_nrows_greater_than_nrows_in_file(self, read_ext):
+        # GH 16645
+        expected = pd.read_excel("test1" + read_ext)
+        num_records_in_file = len(expected)
+        num_rows_to_pull = num_records_in_file + 10
+        actual = pd.read_excel("test1" + read_ext, nrows=num_rows_to_pull)
+        tm.assert_frame_equal(actual, expected)
+
+    def test_read_excel_nrows_non_integer_parameter(self, read_ext):
+        # GH 16645
+        msg = "'nrows' must be an integer >=0"
+        with pytest.raises(ValueError, match=msg):
+            pd.read_excel("test1" + read_ext, nrows="5")
+
+    @pytest.mark.parametrize(
+        "filename,sheet_name,header,index_col,skiprows",
+        [
+            ("testmultiindex", "mi_column", [0, 1], 0, None),
+            ("testmultiindex", "mi_index", None, [0, 1], None),
+            ("testmultiindex", "both", [0, 1], [0, 1], None),
+            ("testmultiindex", "mi_column_name", [0, 1], 0, None),
+            ("testskiprows", "skiprows_list", None, None, [0, 2]),
+            ("testskiprows", "skiprows_list", None, None, lambda x: x in (0, 2)),
+        ],
+    )
+    def test_read_excel_nrows_params(
+        self, read_ext, filename, sheet_name, header, index_col, skiprows
+    ):
+        """
+        For various parameters, we should get the same result whether we
+        limit the rows during load (nrows=3) or after (df.iloc[:3]).
+        """
+        # GH 46894
+        expected = pd.read_excel(
+            filename + read_ext,
+            sheet_name=sheet_name,
+            header=header,
+            index_col=index_col,
+            skiprows=skiprows,
+        ).iloc[:3]
+        actual = pd.read_excel(
+            filename + read_ext,
+            sheet_name=sheet_name,
+            header=header,
+            index_col=index_col,
+            skiprows=skiprows,
+            nrows=3,
+        )
+        tm.assert_frame_equal(actual, expected)
+
+    def test_deprecated_kwargs(self, read_ext):
+        with pytest.raises(TypeError, match="but 3 positional arguments"):
+            pd.read_excel("test1" + read_ext, "Sheet1", 0)
+
+    def test_no_header_with_list_index_col(self, read_ext):
+        # GH 31783
+        file_name = "testmultiindex" + read_ext
+        data = [("B", "B"), ("key", "val"), (3, 4), (3, 4)]
+        idx = MultiIndex.from_tuples(
+            [("A", "A"), ("key", "val"), (1, 2), (1, 2)], names=(0, 1)
+        )
+        expected = DataFrame(data, index=idx, columns=(2, 3))
+        result = pd.read_excel(
+            file_name, sheet_name="index_col_none", index_col=[0, 1], header=None
+        )
+        tm.assert_frame_equal(expected, result)
+
+    def test_one_col_noskip_blank_line(self, read_ext):
+        # GH 39808
+        file_name = "one_col_blank_line" + read_ext
+        data = [0.5, np.nan, 1, 2]
+        expected = DataFrame(data, columns=["numbers"])
+        result = pd.read_excel(file_name)
+        tm.assert_frame_equal(result, expected)
+
+    def test_multiheader_two_blank_lines(self, read_ext):
+        # GH 40442
+        file_name = "testmultiindex" + read_ext
+        columns = MultiIndex.from_tuples([("a", "A"), ("b", "B")])
+        data = [[np.nan, np.nan], [np.nan, np.nan], [1, 3], [2, 4]]
+        expected = DataFrame(data, columns=columns)
+        result = pd.read_excel(
+            file_name, sheet_name="mi_column_empty_rows", header=[0, 1]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_trailing_blanks(self, read_ext):
+        """
+        Sheets can contain blank cells with no data. Some of our readers
+        were including those cells, creating many empty rows and columns
+        """
+        file_name = "trailing_blanks" + read_ext
+        result = pd.read_excel(file_name)
+        assert result.shape == (3, 3)
+
+    def test_ignore_chartsheets_by_str(self, request, engine, read_ext):
+        # GH 41448
+        if engine == "odf":
+            pytest.skip("chartsheets do not exist in the ODF format")
+        if engine == "pyxlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="pyxlsb can't distinguish chartsheets from worksheets"
+                )
+            )
+        with pytest.raises(ValueError, match="Worksheet named 'Chart1' not found"):
+            pd.read_excel("chartsheet" + read_ext, sheet_name="Chart1")
+
+    def test_ignore_chartsheets_by_int(self, request, engine, read_ext):
+        # GH 41448
+        if engine == "odf":
+            pytest.skip("chartsheets do not exist in the ODF format")
+        if engine == "pyxlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="pyxlsb can't distinguish chartsheets from worksheets"
+                )
+            )
+        with pytest.raises(
+            ValueError, match="Worksheet index 1 is invalid, 1 worksheets found"
+        ):
+            pd.read_excel("chartsheet" + read_ext, sheet_name=1)
+
+    def test_euro_decimal_format(self, read_ext):
+        # copied from read_csv
+        result = pd.read_excel("test_decimal" + read_ext, decimal=",", skiprows=1)
+        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)
+
+
+class TestExcelFileRead:
+    @pytest.fixture(autouse=True)
+    def cd_and_set_engine(self, engine, datapath, monkeypatch):
+        """
+        Change directory and set engine for ExcelFile objects.
+        """
+        func = partial(pd.ExcelFile, engine=engine)
+        monkeypatch.chdir(datapath("io", "data", "excel"))
+        monkeypatch.setattr(pd, "ExcelFile", func)
+
+    def test_engine_used(self, read_ext, engine):
+        expected_defaults = {
+            "xlsx": "openpyxl",
+            "xlsm": "openpyxl",
+            "xlsb": "pyxlsb",
+            "xls": "xlrd",
+            "ods": "odf",
+        }
+
+        with pd.ExcelFile("test1" + read_ext) as excel:
+            result = excel.engine
+
+        if engine is not None:
+            expected = engine
+        else:
+            expected = expected_defaults[read_ext[1:]]
+        assert result == expected
+
+    def test_excel_passes_na(self, read_ext):
+        with pd.ExcelFile("test4" + read_ext) as excel:
+            parsed = pd.read_excel(
+                excel, sheet_name="Sheet1", keep_default_na=False, na_values=["apple"]
+            )
+        expected = DataFrame(
+            [["NA"], [1], ["NA"], [np.nan], ["rabbit"]], columns=["Test"]
+        )
+        tm.assert_frame_equal(parsed, expected)
+
+        with pd.ExcelFile("test4" + read_ext) as excel:
+            parsed = pd.read_excel(
+                excel, sheet_name="Sheet1", keep_default_na=True, na_values=["apple"]
+            )
+        expected = DataFrame(
+            [[np.nan], [1], [np.nan], [np.nan], ["rabbit"]], columns=["Test"]
+        )
+        tm.assert_frame_equal(parsed, expected)
+
+        # 13967
+        with pd.ExcelFile("test5" + read_ext) as excel:
+            parsed = pd.read_excel(
+                excel, sheet_name="Sheet1", keep_default_na=False, na_values=["apple"]
+            )
+        expected = DataFrame(
+            [["1.#QNAN"], [1], ["nan"], [np.nan], ["rabbit"]], columns=["Test"]
+        )
+        tm.assert_frame_equal(parsed, expected)
+
+        with pd.ExcelFile("test5" + read_ext) as excel:
+            parsed = pd.read_excel(
+                excel, sheet_name="Sheet1", keep_default_na=True, na_values=["apple"]
+            )
+        expected = DataFrame(
+            [[np.nan], [1], [np.nan], [np.nan], ["rabbit"]], columns=["Test"]
+        )
+        tm.assert_frame_equal(parsed, expected)
+
+    @pytest.mark.parametrize("na_filter", [None, True, False])
+    def test_excel_passes_na_filter(self, read_ext, na_filter):
+        # gh-25453
+        kwargs = {}
+
+        if na_filter is not None:
+            kwargs["na_filter"] = na_filter
+
+        with pd.ExcelFile("test5" + read_ext) as excel:
+            parsed = pd.read_excel(
+                excel,
+                sheet_name="Sheet1",
+                keep_default_na=True,
+                na_values=["apple"],
+                **kwargs,
+            )
+
+        if na_filter is False:
+            expected = [["1.#QNAN"], [1], ["nan"], ["apple"], ["rabbit"]]
+        else:
+            expected = [[np.nan], [1], [np.nan], [np.nan], ["rabbit"]]
+
+        expected = DataFrame(expected, columns=["Test"])
+        tm.assert_frame_equal(parsed, expected)
+
+    def test_excel_table_sheet_by_index(self, request, read_ext, df_ref):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        with pd.ExcelFile("test1" + read_ext) as excel:
+            df1 = pd.read_excel(excel, sheet_name=0, index_col=0)
+            df2 = pd.read_excel(excel, sheet_name=1, skiprows=[1], index_col=0)
+        tm.assert_frame_equal(df1, df_ref, check_names=False)
+        tm.assert_frame_equal(df2, df_ref, check_names=False)
+
+        with pd.ExcelFile("test1" + read_ext) as excel:
+            df1 = excel.parse(0, index_col=0)
+            df2 = excel.parse(1, skiprows=[1], index_col=0)
+        tm.assert_frame_equal(df1, df_ref, check_names=False)
+        tm.assert_frame_equal(df2, df_ref, check_names=False)
+
+        with pd.ExcelFile("test1" + read_ext) as excel:
+            df3 = pd.read_excel(excel, sheet_name=0, index_col=0, skipfooter=1)
+        tm.assert_frame_equal(df3, df1.iloc[:-1])
+
+        with pd.ExcelFile("test1" + read_ext) as excel:
+            df3 = excel.parse(0, index_col=0, skipfooter=1)
+
+        tm.assert_frame_equal(df3, df1.iloc[:-1])
+
+    def test_sheet_name(self, request, read_ext, df_ref):
+        if read_ext == ".xlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        filename = "test1"
+        sheet_name = "Sheet1"
+
+        with pd.ExcelFile(filename + read_ext) as excel:
+            df1_parse = excel.parse(sheet_name=sheet_name, index_col=0)  # doc
+
+        with pd.ExcelFile(filename + read_ext) as excel:
+            df2_parse = excel.parse(index_col=0, sheet_name=sheet_name)
+
+        tm.assert_frame_equal(df1_parse, df_ref, check_names=False)
+        tm.assert_frame_equal(df2_parse, df_ref, check_names=False)
+
+    @pytest.mark.parametrize(
+        "sheet_name",
+        [3, [0, 3], [3, 0], "Sheet4", ["Sheet1", "Sheet4"], ["Sheet4", "Sheet1"]],
+    )
+    def test_bad_sheetname_raises(self, read_ext, sheet_name):
+        # GH 39250
+        msg = "Worksheet index 3 is invalid|Worksheet named 'Sheet4' not found"
+        with pytest.raises(ValueError, match=msg):
+            with pd.ExcelFile("blank" + read_ext) as excel:
+                excel.parse(sheet_name=sheet_name)
+
+    def test_excel_read_buffer(self, engine, read_ext):
+        pth = "test1" + read_ext
+        expected = pd.read_excel(pth, sheet_name="Sheet1", index_col=0, engine=engine)
+
+        with open(pth, "rb") as f:
+            with pd.ExcelFile(f) as xls:
+                actual = pd.read_excel(xls, sheet_name="Sheet1", index_col=0)
+
+        tm.assert_frame_equal(expected, actual)
+
+    def test_reader_closes_file(self, engine, read_ext):
+        with open("test1" + read_ext, "rb") as f:
+            with pd.ExcelFile(f) as xlsx:
+                # parses okay
+                pd.read_excel(xlsx, sheet_name="Sheet1", index_col=0, engine=engine)
+
+        assert f.closed
+
+    def test_conflicting_excel_engines(self, read_ext):
+        # GH 26566
+        msg = "Engine should not be specified when passing an ExcelFile"
+
+        with pd.ExcelFile("test1" + read_ext) as xl:
+            with pytest.raises(ValueError, match=msg):
+                pd.read_excel(xl, engine="foo")
+
+    def test_excel_read_binary(self, engine, read_ext):
+        # GH 15914
+        expected = pd.read_excel("test1" + read_ext, engine=engine)
+
+        with open("test1" + read_ext, "rb") as f:
+            data = f.read()
+
+        actual = pd.read_excel(data, engine=engine)
+        tm.assert_frame_equal(expected, actual)
+
+    def test_excel_read_binary_via_read_excel(self, read_ext, engine):
+        # GH 38424
+        with open("test1" + read_ext, "rb") as f:
+            result = pd.read_excel(f)
+        expected = pd.read_excel("test1" + read_ext, engine=engine)
+        tm.assert_frame_equal(result, expected)
+
+    def test_read_excel_header_index_out_of_range(self, engine):
+        # GH#43143
+        with open("df_header_oob.xlsx", "rb") as f:
+            with pytest.raises(ValueError, match="exceeds maximum"):
+                pd.read_excel(f, header=[0, 1])
+
+    @pytest.mark.parametrize("filename", ["df_empty.xlsx", "df_equals.xlsx"])
+    def test_header_with_index_col(self, filename):
+        # GH 33476
+        idx = Index(["Z"], name="I2")
+        cols = MultiIndex.from_tuples([("A", "B"), ("A", "B.1")], names=["I11", "I12"])
+        expected = DataFrame([[1, 3]], index=idx, columns=cols, dtype="int64")
+        result = pd.read_excel(
+            filename, sheet_name="Sheet1", index_col=0, header=[0, 1]
+        )
+        tm.assert_frame_equal(expected, result)
+
+    def test_read_datetime_multiindex(self, request, engine, read_ext):
+        # GH 34748
+        if engine == "pyxlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="Sheets containing datetimes not supported by pyxlsb"
+                )
+            )
+
+        f = "test_datetime_mi" + read_ext
+        with pd.ExcelFile(f) as excel:
+            actual = pd.read_excel(excel, header=[0, 1], index_col=0, engine=engine)
+        expected_column_index = MultiIndex.from_tuples(
+            [(pd.to_datetime("02/29/2020"), pd.to_datetime("03/01/2020"))],
+            names=[
+                pd.to_datetime("02/29/2020").to_pydatetime(),
+                pd.to_datetime("03/01/2020").to_pydatetime(),
+            ],
+        )
+        expected = DataFrame([], index=[], columns=expected_column_index)
+
+        tm.assert_frame_equal(expected, actual)
+
+    def test_engine_invalid_option(self, read_ext):
+        # read_ext includes the '.' hence the weird formatting
+        with pytest.raises(ValueError, match="Value must be one of *"):
+            with pd.option_context(f"io.excel{read_ext}.reader", "abc"):
+                pass
+
+    def test_ignore_chartsheets(self, request, engine, read_ext):
+        # GH 41448
+        if engine == "odf":
+            pytest.skip("chartsheets do not exist in the ODF format")
+        if engine == "pyxlsb":
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="pyxlsb can't distinguish chartsheets from worksheets"
+                )
+            )
+        with pd.ExcelFile("chartsheet" + read_ext) as excel:
+            assert excel.sheet_names == ["Sheet1"]
+
+    def test_corrupt_files_closed(self, engine, read_ext):
+        # GH41778
+        errors = (BadZipFile,)
+        if engine is None:
+            pytest.skip(f"Invalid test for engine={engine}")
+        elif engine == "xlrd":
+            import xlrd
+
+            errors = (BadZipFile, xlrd.biffh.XLRDError)
+
+        with tm.ensure_clean(f"corrupt{read_ext}") as file:
+            Path(file).write_text("corrupt")
+            with tm.assert_produces_warning(False):
+                try:
+                    pd.ExcelFile(file, engine=engine)
+                except errors:
+                    pass

videochat2/lib/python3.10/site-packages/pandas/tests/io/excel/test_writers.py

@@ -0,0 +1,1334 @@
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+)
+from functools import partial
+from io import BytesIO
+import os
+import re
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    option_context,
+)
+import pandas._testing as tm
+
+from pandas.io.excel import (
+    ExcelFile,
+    ExcelWriter,
+    _OpenpyxlWriter,
+    _XlsxWriter,
+    register_writer,
+)
+from pandas.io.excel._util import _writers
+
+
+@pytest.fixture
+def path(ext):
+    """
+    Fixture to open file for use in each test case.
+    """
+    with tm.ensure_clean(ext) as file_path:
+        yield file_path
+
+
+@pytest.fixture
+def set_engine(engine, ext):
+    """
+    Fixture to set engine for use in each test case.
+
+    Rather than requiring `engine=...` to be provided explicitly as an
+    argument in each test, this fixture sets a global option to dictate
+    which engine should be used to write Excel files. After executing
+    the test it rolls back said change to the global option.
+    """
+    option_name = f"io.excel.{ext.strip('.')}.writer"
+    with option_context(option_name, engine):
+        yield
+
+
+@pytest.mark.parametrize(
+    "ext",
+    [
+        pytest.param(".xlsx", marks=[td.skip_if_no("openpyxl"), td.skip_if_no("xlrd")]),
+        pytest.param(".xlsm", marks=[td.skip_if_no("openpyxl"), td.skip_if_no("xlrd")]),
+        pytest.param(
+            ".xlsx", marks=[td.skip_if_no("xlsxwriter"), td.skip_if_no("xlrd")]
+        ),
+        pytest.param(".ods", marks=td.skip_if_no("odf")),
+    ],
+)
+class TestRoundTrip:
+    @pytest.mark.parametrize(
+        "header,expected",
+        [(None, DataFrame([np.nan] * 4)), (0, DataFrame({"Unnamed: 0": [np.nan] * 3}))],
+    )
+    def test_read_one_empty_col_no_header(self, ext, header, expected):
+        # xref gh-12292
+        filename = "no_header"
+        df = DataFrame([["", 1, 100], ["", 2, 200], ["", 3, 300], ["", 4, 400]])
+
+        with tm.ensure_clean(ext) as path:
+            df.to_excel(path, filename, index=False, header=False)
+            result = pd.read_excel(
+                path, sheet_name=filename, usecols=[0], header=header
+            )
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "header,expected",
+        [(None, DataFrame([0] + [np.nan] * 4)), (0, DataFrame([np.nan] * 4))],
+    )
+    def test_read_one_empty_col_with_header(self, ext, header, expected):
+        filename = "with_header"
+        df = DataFrame([["", 1, 100], ["", 2, 200], ["", 3, 300], ["", 4, 400]])
+
+        with tm.ensure_clean(ext) as path:
+            df.to_excel(path, "with_header", index=False, header=True)
+            result = pd.read_excel(
+                path, sheet_name=filename, usecols=[0], header=header
+            )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_set_column_names_in_parameter(self, ext):
+        # GH 12870 : pass down column names associated with
+        # keyword argument names
+        refdf = DataFrame([[1, "foo"], [2, "bar"], [3, "baz"]], columns=["a", "b"])
+
+        with tm.ensure_clean(ext) as pth:
+            with ExcelWriter(pth) as writer:
+                refdf.to_excel(writer, "Data_no_head", header=False, index=False)
+                refdf.to_excel(writer, "Data_with_head", index=False)
+
+            refdf.columns = ["A", "B"]
+
+            with ExcelFile(pth) as reader:
+                xlsdf_no_head = pd.read_excel(
+                    reader, sheet_name="Data_no_head", header=None, names=["A", "B"]
+                )
+                xlsdf_with_head = pd.read_excel(
+                    reader,
+                    sheet_name="Data_with_head",
+                    index_col=None,
+                    names=["A", "B"],
+                )
+
+            tm.assert_frame_equal(xlsdf_no_head, refdf)
+            tm.assert_frame_equal(xlsdf_with_head, refdf)
+
+    def test_creating_and_reading_multiple_sheets(self, ext):
+        # see gh-9450
+        #
+        # Test reading multiple sheets, from a runtime
+        # created Excel file with multiple sheets.
+        def tdf(col_sheet_name):
+            d, i = [11, 22, 33], [1, 2, 3]
+            return DataFrame(d, i, columns=[col_sheet_name])
+
+        sheets = ["AAA", "BBB", "CCC"]
+
+        dfs = [tdf(s) for s in sheets]
+        dfs = dict(zip(sheets, dfs))
+
+        with tm.ensure_clean(ext) as pth:
+            with ExcelWriter(pth) as ew:
+                for sheetname, df in dfs.items():
+                    df.to_excel(ew, sheetname)
+
+            dfs_returned = pd.read_excel(pth, sheet_name=sheets, index_col=0)
+
+            for s in sheets:
+                tm.assert_frame_equal(dfs[s], dfs_returned[s])
+
+    def test_read_excel_multiindex_empty_level(self, ext):
+        # see gh-12453
+        with tm.ensure_clean(ext) as path:
+            df = DataFrame(
+                {
+                    ("One", "x"): {0: 1},
+                    ("Two", "X"): {0: 3},
+                    ("Two", "Y"): {0: 7},
+                    ("Zero", ""): {0: 0},
+                }
+            )
+
+            expected = DataFrame(
+                {
+                    ("One", "x"): {0: 1},
+                    ("Two", "X"): {0: 3},
+                    ("Two", "Y"): {0: 7},
+                    ("Zero", "Unnamed: 4_level_1"): {0: 0},
+                }
+            )
+
+            df.to_excel(path)
+            actual = pd.read_excel(path, header=[0, 1], index_col=0)
+            tm.assert_frame_equal(actual, expected)
+
+            df = DataFrame(
+                {
+                    ("Beg", ""): {0: 0},
+                    ("Middle", "x"): {0: 1},
+                    ("Tail", "X"): {0: 3},
+                    ("Tail", "Y"): {0: 7},
+                }
+            )
+
+            expected = DataFrame(
+                {
+                    ("Beg", "Unnamed: 1_level_1"): {0: 0},
+                    ("Middle", "x"): {0: 1},
+                    ("Tail", "X"): {0: 3},
+                    ("Tail", "Y"): {0: 7},
+                }
+            )
+
+            df.to_excel(path)
+            actual = pd.read_excel(path, header=[0, 1], index_col=0)
+            tm.assert_frame_equal(actual, expected)
+
+    @pytest.mark.parametrize("c_idx_names", [True, False])
+    @pytest.mark.parametrize("r_idx_names", [True, False])
+    @pytest.mark.parametrize("c_idx_levels", [1, 3])
+    @pytest.mark.parametrize("r_idx_levels", [1, 3])
+    def test_excel_multindex_roundtrip(
+        self, ext, c_idx_names, r_idx_names, c_idx_levels, r_idx_levels, request
+    ):
+        # see gh-4679
+        with tm.ensure_clean(ext) as pth:
+            if (c_idx_levels == 1 and c_idx_names) and not (
+                r_idx_levels == 3 and not r_idx_names
+            ):
+                mark = pytest.mark.xfail(
+                    reason="Column index name cannot be serialized unless "
+                    "it's a MultiIndex"
+                )
+                request.node.add_marker(mark)
+
+            # Empty name case current read in as
+            # unnamed levels, not Nones.
+            check_names = r_idx_names or r_idx_levels <= 1
+
+            df = tm.makeCustomDataframe(
+                5, 5, c_idx_names, r_idx_names, c_idx_levels, r_idx_levels
+            )
+            df.to_excel(pth)
+
+            act = pd.read_excel(
+                pth,
+                index_col=list(range(r_idx_levels)),
+                header=list(range(c_idx_levels)),
+            )
+            tm.assert_frame_equal(df, act, check_names=check_names)
+
+            df.iloc[0, :] = np.nan
+            df.to_excel(pth)
+
+            act = pd.read_excel(
+                pth,
+                index_col=list(range(r_idx_levels)),
+                header=list(range(c_idx_levels)),
+            )
+            tm.assert_frame_equal(df, act, check_names=check_names)
+
+            df.iloc[-1, :] = np.nan
+            df.to_excel(pth)
+            act = pd.read_excel(
+                pth,
+                index_col=list(range(r_idx_levels)),
+                header=list(range(c_idx_levels)),
+            )
+            tm.assert_frame_equal(df, act, check_names=check_names)
+
+    def test_read_excel_parse_dates(self, ext):
+        # see gh-11544, gh-12051
+        df = DataFrame(
+            {"col": [1, 2, 3], "date_strings": pd.date_range("2012-01-01", periods=3)}
+        )
+        df2 = df.copy()
+        df2["date_strings"] = df2["date_strings"].dt.strftime("%m/%d/%Y")
+
+        with tm.ensure_clean(ext) as pth:
+            df2.to_excel(pth)
+
+            res = pd.read_excel(pth, index_col=0)
+            tm.assert_frame_equal(df2, res)
+
+            res = pd.read_excel(pth, parse_dates=["date_strings"], index_col=0)
+            tm.assert_frame_equal(df, res)
+
+            date_parser = lambda x: datetime.strptime(x, "%m/%d/%Y")
+            with tm.assert_produces_warning(
+                FutureWarning, match="use 'date_format' instead"
+            ):
+                res = pd.read_excel(
+                    pth,
+                    parse_dates=["date_strings"],
+                    date_parser=date_parser,
+                    index_col=0,
+                )
+            tm.assert_frame_equal(df, res)
+            res = pd.read_excel(
+                pth, parse_dates=["date_strings"], date_format="%m/%d/%Y", index_col=0
+            )
+            tm.assert_frame_equal(df, res)
+
+    def test_multiindex_interval_datetimes(self, ext):
+        # GH 30986
+        midx = MultiIndex.from_arrays(
+            [
+                range(4),
+                pd.interval_range(
+                    start=pd.Timestamp("2020-01-01"), periods=4, freq="6M"
+                ),
+            ]
+        )
+        df = DataFrame(range(4), index=midx)
+        with tm.ensure_clean(ext) as pth:
+            df.to_excel(pth)
+            result = pd.read_excel(pth, index_col=[0, 1])
+        expected = DataFrame(
+            range(4),
+            MultiIndex.from_arrays(
+                [
+                    range(4),
+                    [
+                        "(2020-01-31, 2020-07-31]",
+                        "(2020-07-31, 2021-01-31]",
+                        "(2021-01-31, 2021-07-31]",
+                        "(2021-07-31, 2022-01-31]",
+                    ],
+                ]
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "engine,ext",
+    [
+        pytest.param(
+            "openpyxl",
+            ".xlsx",
+            marks=[td.skip_if_no("openpyxl"), td.skip_if_no("xlrd")],
+        ),
+        pytest.param(
+            "openpyxl",
+            ".xlsm",
+            marks=[td.skip_if_no("openpyxl"), td.skip_if_no("xlrd")],
+        ),
+        pytest.param(
+            "xlsxwriter",
+            ".xlsx",
+            marks=[td.skip_if_no("xlsxwriter"), td.skip_if_no("xlrd")],
+        ),
+        pytest.param("odf", ".ods", marks=td.skip_if_no("odf")),
+    ],
+)
+@pytest.mark.usefixtures("set_engine")
+class TestExcelWriter:
+    def test_excel_sheet_size(self, path):
+        # GH 26080
+        breaking_row_count = 2**20 + 1
+        breaking_col_count = 2**14 + 1
+        # purposely using two arrays to prevent memory issues while testing
+        row_arr = np.zeros(shape=(breaking_row_count, 1))
+        col_arr = np.zeros(shape=(1, breaking_col_count))
+        row_df = DataFrame(row_arr)
+        col_df = DataFrame(col_arr)
+
+        msg = "sheet is too large"
+        with pytest.raises(ValueError, match=msg):
+            row_df.to_excel(path)
+
+        with pytest.raises(ValueError, match=msg):
+            col_df.to_excel(path)
+
+    def test_excel_sheet_by_name_raise(self, path):
+        gt = DataFrame(np.random.randn(10, 2))
+        gt.to_excel(path)
+
+        with ExcelFile(path) as xl:
+            df = pd.read_excel(xl, sheet_name=0, index_col=0)
+
+        tm.assert_frame_equal(gt, df)
+
+        msg = "Worksheet named '0' not found"
+        with pytest.raises(ValueError, match=msg):
+            pd.read_excel(xl, "0")
+
+    def test_excel_writer_context_manager(self, frame, path):
+        with ExcelWriter(path) as writer:
+            frame.to_excel(writer, "Data1")
+            frame2 = frame.copy()
+            frame2.columns = frame.columns[::-1]
+            frame2.to_excel(writer, "Data2")
+
+        with ExcelFile(path) as reader:
+            found_df = pd.read_excel(reader, sheet_name="Data1", index_col=0)
+            found_df2 = pd.read_excel(reader, sheet_name="Data2", index_col=0)
+
+            tm.assert_frame_equal(found_df, frame)
+            tm.assert_frame_equal(found_df2, frame2)
+
+    def test_roundtrip(self, frame, path):
+        frame = frame.copy()
+        frame.iloc[:5, frame.columns.get_loc("A")] = np.nan
+
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
+
+        # test roundtrip
+        frame.to_excel(path, "test1")
+        recons = pd.read_excel(path, sheet_name="test1", index_col=0)
+        tm.assert_frame_equal(frame, recons)
+
+        frame.to_excel(path, "test1", index=False)
+        recons = pd.read_excel(path, sheet_name="test1", index_col=None)
+        recons.index = frame.index
+        tm.assert_frame_equal(frame, recons)
+
+        frame.to_excel(path, "test1", na_rep="NA")
+        recons = pd.read_excel(path, sheet_name="test1", index_col=0, na_values=["NA"])
+        tm.assert_frame_equal(frame, recons)
+
+        # GH 3611
+        frame.to_excel(path, "test1", na_rep="88")
+        recons = pd.read_excel(path, sheet_name="test1", index_col=0, na_values=["88"])
+        tm.assert_frame_equal(frame, recons)
+
+        frame.to_excel(path, "test1", na_rep="88")
+        recons = pd.read_excel(
+            path, sheet_name="test1", index_col=0, na_values=[88, 88.0]
+        )
+        tm.assert_frame_equal(frame, recons)
+
+        # GH 6573
+        frame.to_excel(path, "Sheet1")
+        recons = pd.read_excel(path, index_col=0)
+        tm.assert_frame_equal(frame, recons)
+
+        frame.to_excel(path, "0")
+        recons = pd.read_excel(path, index_col=0)
+        tm.assert_frame_equal(frame, recons)
+
+        # GH 8825 Pandas Series should provide to_excel method
+        s = frame["A"]
+        s.to_excel(path)
+        recons = pd.read_excel(path, index_col=0)
+        tm.assert_frame_equal(s.to_frame(), recons)
+
+    def test_mixed(self, frame, path):
+        mixed_frame = frame.copy()
+        mixed_frame["foo"] = "bar"
+
+        mixed_frame.to_excel(path, "test1")
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
+        tm.assert_frame_equal(mixed_frame, recons)
+
+    def test_ts_frame(self, tsframe, path):
+        df = tsframe
+
+        # freq doesn't round-trip
+        index = pd.DatetimeIndex(np.asarray(df.index), freq=None)
+        df.index = index
+
+        df.to_excel(path, "test1")
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
+        tm.assert_frame_equal(df, recons)
+
+    def test_basics_with_nan(self, frame, path):
+        frame = frame.copy()
+        frame.iloc[:5, frame.columns.get_loc("A")] = np.nan
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
+
+    @pytest.mark.parametrize("np_type", [np.int8, np.int16, np.int32, np.int64])
+    def test_int_types(self, np_type, path):
+        # Test np.int values read come back as int
+        # (rather than float which is Excel's format).
+        df = DataFrame(np.random.randint(-10, 10, size=(10, 2)), dtype=np_type)
+        df.to_excel(path, "test1")
+
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
+
+        int_frame = df.astype(np.int64)
+        tm.assert_frame_equal(int_frame, recons)
+
+        recons2 = pd.read_excel(path, sheet_name="test1", index_col=0)
+        tm.assert_frame_equal(int_frame, recons2)
+
+    @pytest.mark.parametrize("np_type", [np.float16, np.float32, np.float64])
+    def test_float_types(self, np_type, path):
+        # Test np.float values read come back as float.
+        df = DataFrame(np.random.random_sample(10), dtype=np_type)
+        df.to_excel(path, "test1")
+
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0).astype(
+                np_type
+            )
+
+        tm.assert_frame_equal(df, recons)
+
+    def test_bool_types(self, path):
+        # Test np.bool_ values read come back as float.
+        df = DataFrame([1, 0, True, False], dtype=np.bool_)
+        df.to_excel(path, "test1")
+
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0).astype(
+                np.bool_
+            )
+
+        tm.assert_frame_equal(df, recons)
+
+    def test_inf_roundtrip(self, path):
+        df = DataFrame([(1, np.inf), (2, 3), (5, -np.inf)])
+        df.to_excel(path, "test1")
+
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
+
+        tm.assert_frame_equal(df, recons)
+
+    def test_sheets(self, frame, tsframe, path):
+        # freq doesn't round-trip
+        index = pd.DatetimeIndex(np.asarray(tsframe.index), freq=None)
+        tsframe.index = index
+
+        frame = frame.copy()
+        frame.iloc[:5, frame.columns.get_loc("A")] = np.nan
+
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
+
+        # Test writing to separate sheets
+        with ExcelWriter(path) as writer:
+            frame.to_excel(writer, "test1")
+            tsframe.to_excel(writer, "test2")
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
+            tm.assert_frame_equal(frame, recons)
+            recons = pd.read_excel(reader, sheet_name="test2", index_col=0)
+            tm.assert_frame_equal(tsframe, recons)
+        assert 2 == len(reader.sheet_names)
+        assert "test1" == reader.sheet_names[0]
+        assert "test2" == reader.sheet_names[1]
+
+    def test_colaliases(self, frame, path):
+        frame = frame.copy()
+        frame.iloc[:5, frame.columns.get_loc("A")] = np.nan
+
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
+
+        # column aliases
+        col_aliases = Index(["AA", "X", "Y", "Z"])
+        frame.to_excel(path, "test1", header=col_aliases)
+        with ExcelFile(path) as reader:
+            rs = pd.read_excel(reader, sheet_name="test1", index_col=0)
+        xp = frame.copy()
+        xp.columns = col_aliases
+        tm.assert_frame_equal(xp, rs)
+
+    def test_roundtrip_indexlabels(self, merge_cells, frame, path):
+        frame = frame.copy()
+        frame.iloc[:5, frame.columns.get_loc("A")] = np.nan
+
+        frame.to_excel(path, "test1")
+        frame.to_excel(path, "test1", columns=["A", "B"])
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", index=False)
+
+        # test index_label
+        df = DataFrame(np.random.randn(10, 2)) >= 0
+        df.to_excel(path, "test1", index_label=["test"], merge_cells=merge_cells)
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0).astype(
+                np.int64
+            )
+        df.index.names = ["test"]
+        assert df.index.names == recons.index.names
+
+        df = DataFrame(np.random.randn(10, 2)) >= 0
+        df.to_excel(
+            path,
+            "test1",
+            index_label=["test", "dummy", "dummy2"],
+            merge_cells=merge_cells,
+        )
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0).astype(
+                np.int64
+            )
+        df.index.names = ["test"]
+        assert df.index.names == recons.index.names
+
+        df = DataFrame(np.random.randn(10, 2)) >= 0
+        df.to_excel(path, "test1", index_label="test", merge_cells=merge_cells)
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0).astype(
+                np.int64
+            )
+        df.index.names = ["test"]
+        tm.assert_frame_equal(df, recons.astype(bool))
+
+        frame.to_excel(
+            path,
+            "test1",
+            columns=["A", "B", "C", "D"],
+            index=False,
+            merge_cells=merge_cells,
+        )
+        # take 'A' and 'B' as indexes (same row as cols 'C', 'D')
+        df = frame.copy()
+        df = df.set_index(["A", "B"])
+
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=[0, 1])
+        tm.assert_frame_equal(df, recons)
+
+    def test_excel_roundtrip_indexname(self, merge_cells, path):
+        df = DataFrame(np.random.randn(10, 4))
+        df.index.name = "foo"
+
+        df.to_excel(path, merge_cells=merge_cells)
+
+        with ExcelFile(path) as xf:
+            result = pd.read_excel(xf, sheet_name=xf.sheet_names[0], index_col=0)
+
+        tm.assert_frame_equal(result, df)
+        assert result.index.name == "foo"
+
+    def test_excel_roundtrip_datetime(self, merge_cells, tsframe, path):
+        # datetime.date, not sure what to test here exactly
+
+        # freq does not round-trip
+        index = pd.DatetimeIndex(np.asarray(tsframe.index), freq=None)
+        tsframe.index = index
+
+        tsf = tsframe.copy()
+
+        tsf.index = [x.date() for x in tsframe.index]
+        tsf.to_excel(path, "test1", merge_cells=merge_cells)
+
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
+
+        tm.assert_frame_equal(tsframe, recons)
+
+    def test_excel_date_datetime_format(self, ext, path):
+        # see gh-4133
+        #
+        # Excel output format strings
+        df = DataFrame(
+            [
+                [date(2014, 1, 31), date(1999, 9, 24)],
+                [datetime(1998, 5, 26, 23, 33, 4), datetime(2014, 2, 28, 13, 5, 13)],
+            ],
+            index=["DATE", "DATETIME"],
+            columns=["X", "Y"],
+        )
+        df_expected = DataFrame(
+            [
+                [datetime(2014, 1, 31), datetime(1999, 9, 24)],
+                [datetime(1998, 5, 26, 23, 33, 4), datetime(2014, 2, 28, 13, 5, 13)],
+            ],
+            index=["DATE", "DATETIME"],
+            columns=["X", "Y"],
+        )
+
+        with tm.ensure_clean(ext) as filename2:
+            with ExcelWriter(path) as writer1:
+                df.to_excel(writer1, "test1")
+
+            with ExcelWriter(
+                filename2,
+                date_format="DD.MM.YYYY",
+                datetime_format="DD.MM.YYYY HH-MM-SS",
+            ) as writer2:
+                df.to_excel(writer2, "test1")
+
+            with ExcelFile(path) as reader1:
+                rs1 = pd.read_excel(reader1, sheet_name="test1", index_col=0)
+
+            with ExcelFile(filename2) as reader2:
+                rs2 = pd.read_excel(reader2, sheet_name="test1", index_col=0)
+
+        tm.assert_frame_equal(rs1, rs2)
+
+        # Since the reader returns a datetime object for dates,
+        # we need to use df_expected to check the result.
+        tm.assert_frame_equal(rs2, df_expected)
+
+    def test_to_excel_interval_no_labels(self, path):
+        # see gh-19242
+        #
+        # Test writing Interval without labels.
+        df = DataFrame(np.random.randint(-10, 10, size=(20, 1)), dtype=np.int64)
+        expected = df.copy()
+
+        df["new"] = pd.cut(df[0], 10)
+        expected["new"] = pd.cut(expected[0], 10).astype(str)
+
+        df.to_excel(path, "test1")
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
+        tm.assert_frame_equal(expected, recons)
+
+    def test_to_excel_interval_labels(self, path):
+        # see gh-19242
+        #
+        # Test writing Interval with labels.
+        df = DataFrame(np.random.randint(-10, 10, size=(20, 1)), dtype=np.int64)
+        expected = df.copy()
+        intervals = pd.cut(
+            df[0], 10, labels=["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
+        )
+        df["new"] = intervals
+        expected["new"] = pd.Series(list(intervals))
+
+        df.to_excel(path, "test1")
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
+        tm.assert_frame_equal(expected, recons)
+
+    def test_to_excel_timedelta(self, path):
+        # see gh-19242, gh-9155
+        #
+        # Test writing timedelta to xls.
+        df = DataFrame(
+            np.random.randint(-10, 10, size=(20, 1)), columns=["A"], dtype=np.int64
+        )
+        expected = df.copy()
+
+        df["new"] = df["A"].apply(lambda x: timedelta(seconds=x))
+        expected["new"] = expected["A"].apply(
+            lambda x: timedelta(seconds=x).total_seconds() / 86400
+        )
+
+        df.to_excel(path, "test1")
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
+        tm.assert_frame_equal(expected, recons)
+
+    def test_to_excel_periodindex(self, tsframe, path):
+        xp = tsframe.resample("M", kind="period").mean()
+
+        xp.to_excel(path, "sht1")
+
+        with ExcelFile(path) as reader:
+            rs = pd.read_excel(reader, sheet_name="sht1", index_col=0)
+        tm.assert_frame_equal(xp, rs.to_period("M"))
+
+    def test_to_excel_multiindex(self, merge_cells, frame, path):
+        arrays = np.arange(len(frame.index) * 2, dtype=np.int64).reshape(2, -1)
+        new_index = MultiIndex.from_arrays(arrays, names=["first", "second"])
+        frame.index = new_index
+
+        frame.to_excel(path, "test1", header=False)
+        frame.to_excel(path, "test1", columns=["A", "B"])
+
+        # round trip
+        frame.to_excel(path, "test1", merge_cells=merge_cells)
+        with ExcelFile(path) as reader:
+            df = pd.read_excel(reader, sheet_name="test1", index_col=[0, 1])
+        tm.assert_frame_equal(frame, df)
+
+    # GH13511
+    def test_to_excel_multiindex_nan_label(self, merge_cells, path):
+        df = DataFrame({"A": [None, 2, 3], "B": [10, 20, 30], "C": np.random.sample(3)})
+        df = df.set_index(["A", "B"])
+
+        df.to_excel(path, merge_cells=merge_cells)
+        df1 = pd.read_excel(path, index_col=[0, 1])
+        tm.assert_frame_equal(df, df1)
+
+    # Test for Issue 11328. If column indices are integers, make
+    # sure they are handled correctly for either setting of
+    # merge_cells
+    def test_to_excel_multiindex_cols(self, merge_cells, frame, path):
+        arrays = np.arange(len(frame.index) * 2, dtype=np.int64).reshape(2, -1)
+        new_index = MultiIndex.from_arrays(arrays, names=["first", "second"])
+        frame.index = new_index
+
+        new_cols_index = MultiIndex.from_tuples([(40, 1), (40, 2), (50, 1), (50, 2)])
+        frame.columns = new_cols_index
+        header = [0, 1]
+        if not merge_cells:
+            header = 0
+
+        # round trip
+        frame.to_excel(path, "test1", merge_cells=merge_cells)
+        with ExcelFile(path) as reader:
+            df = pd.read_excel(
+                reader, sheet_name="test1", header=header, index_col=[0, 1]
+            )
+        if not merge_cells:
+            fm = frame.columns.format(sparsify=False, adjoin=False, names=False)
+            frame.columns = [".".join(map(str, q)) for q in zip(*fm)]
+        tm.assert_frame_equal(frame, df)
+
+    def test_to_excel_multiindex_dates(self, merge_cells, tsframe, path):
+        # try multiindex with dates
+        new_index = [tsframe.index, np.arange(len(tsframe.index), dtype=np.int64)]
+        tsframe.index = MultiIndex.from_arrays(new_index)
+
+        tsframe.index.names = ["time", "foo"]
+        tsframe.to_excel(path, "test1", merge_cells=merge_cells)
+        with ExcelFile(path) as reader:
+            recons = pd.read_excel(reader, sheet_name="test1", index_col=[0, 1])
+
+        tm.assert_frame_equal(tsframe, recons)
+        assert recons.index.names == ("time", "foo")
+
+    def test_to_excel_multiindex_no_write_index(self, path):
+        # Test writing and re-reading a MI without the index. GH 5616.
+
+        # Initial non-MI frame.
+        frame1 = DataFrame({"a": [10, 20], "b": [30, 40], "c": [50, 60]})
+
+        # Add a MI.
+        frame2 = frame1.copy()
+        multi_index = MultiIndex.from_tuples([(70, 80), (90, 100)])
+        frame2.index = multi_index
+
+        # Write out to Excel without the index.
+        frame2.to_excel(path, "test1", index=False)
+
+        # Read it back in.
+        with ExcelFile(path) as reader:
+            frame3 = pd.read_excel(reader, sheet_name="test1")
+
+        # Test that it is the same as the initial frame.
+        tm.assert_frame_equal(frame1, frame3)
+
+    def test_to_excel_empty_multiindex(self, path):
+        # GH 19543.
+        expected = DataFrame([], columns=[0, 1, 2])
+
+        df = DataFrame([], index=MultiIndex.from_tuples([], names=[0, 1]), columns=[2])
+        df.to_excel(path, "test1")
+
+        with ExcelFile(path) as reader:
+            result = pd.read_excel(reader, sheet_name="test1")
+        tm.assert_frame_equal(
+            result, expected, check_index_type=False, check_dtype=False
+        )
+
+    def test_to_excel_float_format(self, path):
+        df = DataFrame(
+            [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+            index=["A", "B"],
+            columns=["X", "Y", "Z"],
+        )
+        df.to_excel(path, "test1", float_format="%.2f")
+
+        with ExcelFile(path) as reader:
+            result = pd.read_excel(reader, sheet_name="test1", index_col=0)
+
+        expected = DataFrame(
+            [[0.12, 0.23, 0.57], [12.32, 123123.20, 321321.20]],
+            index=["A", "B"],
+            columns=["X", "Y", "Z"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_to_excel_output_encoding(self, ext):
+        # Avoid mixed inferred_type.
+        df = DataFrame(
+            [["\u0192", "\u0193", "\u0194"], ["\u0195", "\u0196", "\u0197"]],
+            index=["A\u0192", "B"],
+            columns=["X\u0193", "Y", "Z"],
+        )
+
+        with tm.ensure_clean("__tmp_to_excel_float_format__." + ext) as filename:
+            df.to_excel(filename, sheet_name="TestSheet")
+            result = pd.read_excel(filename, sheet_name="TestSheet", index_col=0)
+            tm.assert_frame_equal(result, df)
+
+    def test_to_excel_unicode_filename(self, ext):
+        with tm.ensure_clean("\u0192u." + ext) as filename:
+            try:
+                with open(filename, "wb"):
+                    pass
+            except UnicodeEncodeError:
+                pytest.skip("No unicode file names on this system")
+
+            df = DataFrame(
+                [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+                index=["A", "B"],
+                columns=["X", "Y", "Z"],
+            )
+            df.to_excel(filename, "test1", float_format="%.2f")
+
+            with ExcelFile(filename) as reader:
+                result = pd.read_excel(reader, sheet_name="test1", index_col=0)
+
+        expected = DataFrame(
+            [[0.12, 0.23, 0.57], [12.32, 123123.20, 321321.20]],
+            index=["A", "B"],
+            columns=["X", "Y", "Z"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("use_headers", [True, False])
+    @pytest.mark.parametrize("r_idx_nlevels", [1, 2, 3])
+    @pytest.mark.parametrize("c_idx_nlevels", [1, 2, 3])
+    def test_excel_010_hemstring(
+        self, merge_cells, c_idx_nlevels, r_idx_nlevels, use_headers, path
+    ):
+        def roundtrip(data, header=True, parser_hdr=0, index=True):
+            data.to_excel(path, header=header, merge_cells=merge_cells, index=index)
+
+            with ExcelFile(path) as xf:
+                return pd.read_excel(
+                    xf, sheet_name=xf.sheet_names[0], header=parser_hdr
+                )
+
+        # Basic test.
+        parser_header = 0 if use_headers else None
+        res = roundtrip(DataFrame([0]), use_headers, parser_header)
+
+        assert res.shape == (1, 2)
+        assert res.iloc[0, 0] is not np.nan
+
+        # More complex tests with multi-index.
+        nrows = 5
+        ncols = 3
+
+        # ensure limited functionality in 0.10
+        # override of gh-2370 until sorted out in 0.11
+
+        df = tm.makeCustomDataframe(
+            nrows, ncols, r_idx_nlevels=r_idx_nlevels, c_idx_nlevels=c_idx_nlevels
+        )
+
+        # This if will be removed once multi-column Excel writing
+        # is implemented. For now fixing gh-9794.
+        if c_idx_nlevels > 1:
+            msg = (
+                "Writing to Excel with MultiIndex columns and no index "
+                "\\('index'=False\\) is not yet implemented."
+            )
+            with pytest.raises(NotImplementedError, match=msg):
+                roundtrip(df, use_headers, index=False)
+        else:
+            res = roundtrip(df, use_headers)
+
+            if use_headers:
+                assert res.shape == (nrows, ncols + r_idx_nlevels)
+            else:
+                # First row taken as columns.
+                assert res.shape == (nrows - 1, ncols + r_idx_nlevels)
+
+            # No NaNs.
+            for r in range(len(res.index)):
+                for c in range(len(res.columns)):
+                    assert res.iloc[r, c] is not np.nan
+
+    def test_duplicated_columns(self, path):
+        # see gh-5235
+        df = DataFrame([[1, 2, 3], [1, 2, 3], [1, 2, 3]], columns=["A", "B", "B"])
+        df.to_excel(path, "test1")
+        expected = DataFrame(
+            [[1, 2, 3], [1, 2, 3], [1, 2, 3]], columns=["A", "B", "B.1"]
+        )
+
+        # By default, we mangle.
+        result = pd.read_excel(path, sheet_name="test1", index_col=0)
+        tm.assert_frame_equal(result, expected)
+
+        # see gh-11007, gh-10970
+        df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "A", "B"])
+        df.to_excel(path, "test1")
+
+        result = pd.read_excel(path, sheet_name="test1", index_col=0)
+        expected = DataFrame(
+            [[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "A.1", "B.1"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # see gh-10982
+        df.to_excel(path, "test1", index=False, header=False)
+        result = pd.read_excel(path, sheet_name="test1", header=None)
+
+        expected = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]])
+        tm.assert_frame_equal(result, expected)
+
+    def test_swapped_columns(self, path):
+        # Test for issue #5427.
+        write_frame = DataFrame({"A": [1, 1, 1], "B": [2, 2, 2]})
+        write_frame.to_excel(path, "test1", columns=["B", "A"])
+
+        read_frame = pd.read_excel(path, sheet_name="test1", header=0)
+
+        tm.assert_series_equal(write_frame["A"], read_frame["A"])
+        tm.assert_series_equal(write_frame["B"], read_frame["B"])
+
+    def test_invalid_columns(self, path):
+        # see gh-10982
+        write_frame = DataFrame({"A": [1, 1, 1], "B": [2, 2, 2]})
+
+        with pytest.raises(KeyError, match="Not all names specified"):
+            write_frame.to_excel(path, "test1", columns=["B", "C"])
+
+        with pytest.raises(
+            KeyError, match="'passes columns are not ALL present dataframe'"
+        ):
+            write_frame.to_excel(path, "test1", columns=["C", "D"])
+
+    @pytest.mark.parametrize(
+        "to_excel_index,read_excel_index_col",
+        [
+            (True, 0),  # Include index in write to file
+            (False, None),  # Dont include index in write to file
+        ],
+    )
+    def test_write_subset_columns(self, path, to_excel_index, read_excel_index_col):
+        # GH 31677
+        write_frame = DataFrame({"A": [1, 1, 1], "B": [2, 2, 2], "C": [3, 3, 3]})
+        write_frame.to_excel(
+            path, "col_subset_bug", columns=["A", "B"], index=to_excel_index
+        )
+
+        expected = write_frame[["A", "B"]]
+        read_frame = pd.read_excel(
+            path, sheet_name="col_subset_bug", index_col=read_excel_index_col
+        )
+
+        tm.assert_frame_equal(expected, read_frame)
+
+    def test_comment_arg(self, path):
+        # see gh-18735
+        #
+        # Test the comment argument functionality to pd.read_excel.
+
+        # Create file to read in.
+        df = DataFrame({"A": ["one", "#one", "one"], "B": ["two", "two", "#two"]})
+        df.to_excel(path, "test_c")
+
+        # Read file without comment arg.
+        result1 = pd.read_excel(path, sheet_name="test_c", index_col=0)
+
+        result1.iloc[1, 0] = None
+        result1.iloc[1, 1] = None
+        result1.iloc[2, 1] = None
+
+        result2 = pd.read_excel(path, sheet_name="test_c", comment="#", index_col=0)
+        tm.assert_frame_equal(result1, result2)
+
+    def test_comment_default(self, path):
+        # Re issue #18735
+        # Test the comment argument default to pd.read_excel
+
+        # Create file to read in
+        df = DataFrame({"A": ["one", "#one", "one"], "B": ["two", "two", "#two"]})
+        df.to_excel(path, "test_c")
+
+        # Read file with default and explicit comment=None
+        result1 = pd.read_excel(path, sheet_name="test_c")
+        result2 = pd.read_excel(path, sheet_name="test_c", comment=None)
+        tm.assert_frame_equal(result1, result2)
+
+    def test_comment_used(self, path):
+        # see gh-18735
+        #
+        # Test the comment argument is working as expected when used.
+
+        # Create file to read in.
+        df = DataFrame({"A": ["one", "#one", "one"], "B": ["two", "two", "#two"]})
+        df.to_excel(path, "test_c")
+
+        # Test read_frame_comment against manually produced expected output.
+        expected = DataFrame({"A": ["one", None, "one"], "B": ["two", None, None]})
+        result = pd.read_excel(path, sheet_name="test_c", comment="#", index_col=0)
+        tm.assert_frame_equal(result, expected)
+
+    def test_comment_empty_line(self, path):
+        # Re issue #18735
+        # Test that pd.read_excel ignores commented lines at the end of file
+
+        df = DataFrame({"a": ["1", "#2"], "b": ["2", "3"]})
+        df.to_excel(path, index=False)
+
+        # Test that all-comment lines at EoF are ignored
+        expected = DataFrame({"a": [1], "b": [2]})
+        result = pd.read_excel(path, comment="#")
+        tm.assert_frame_equal(result, expected)
+
+    def test_datetimes(self, path):
+        # Test writing and reading datetimes. For issue #9139. (xref #9185)
+        datetimes = [
+            datetime(2013, 1, 13, 1, 2, 3),
+            datetime(2013, 1, 13, 2, 45, 56),
+            datetime(2013, 1, 13, 4, 29, 49),
+            datetime(2013, 1, 13, 6, 13, 42),
+            datetime(2013, 1, 13, 7, 57, 35),
+            datetime(2013, 1, 13, 9, 41, 28),
+            datetime(2013, 1, 13, 11, 25, 21),
+            datetime(2013, 1, 13, 13, 9, 14),
+            datetime(2013, 1, 13, 14, 53, 7),
+            datetime(2013, 1, 13, 16, 37, 0),
+            datetime(2013, 1, 13, 18, 20, 52),
+        ]
+
+        write_frame = DataFrame({"A": datetimes})
+        write_frame.to_excel(path, "Sheet1")
+        read_frame = pd.read_excel(path, sheet_name="Sheet1", header=0)
+
+        tm.assert_series_equal(write_frame["A"], read_frame["A"])
+
+    def test_bytes_io(self, engine):
+        # see gh-7074
+        with BytesIO() as bio:
+            df = DataFrame(np.random.randn(10, 2))
+
+            # Pass engine explicitly, as there is no file path to infer from.
+            with ExcelWriter(bio, engine=engine) as writer:
+                df.to_excel(writer)
+
+            bio.seek(0)
+            reread_df = pd.read_excel(bio, index_col=0)
+            tm.assert_frame_equal(df, reread_df)
+
+    def test_write_lists_dict(self, path):
+        # see gh-8188.
+        df = DataFrame(
+            {
+                "mixed": ["a", ["b", "c"], {"d": "e", "f": 2}],
+                "numeric": [1, 2, 3.0],
+                "str": ["apple", "banana", "cherry"],
+            }
+        )
+        df.to_excel(path, "Sheet1")
+        read = pd.read_excel(path, sheet_name="Sheet1", header=0, index_col=0)
+
+        expected = df.copy()
+        expected.mixed = expected.mixed.apply(str)
+        expected.numeric = expected.numeric.astype("int64")
+
+        tm.assert_frame_equal(read, expected)
+
+    def test_render_as_column_name(self, path):
+        # see gh-34331
+        df = DataFrame({"render": [1, 2], "data": [3, 4]})
+        df.to_excel(path, "Sheet1")
+        read = pd.read_excel(path, "Sheet1", index_col=0)
+        expected = df
+        tm.assert_frame_equal(read, expected)
+
+    def test_true_and_false_value_options(self, path):
+        # see gh-13347
+        df = DataFrame([["foo", "bar"]], columns=["col1", "col2"])
+        expected = df.replace({"foo": True, "bar": False})
+
+        df.to_excel(path)
+        read_frame = pd.read_excel(
+            path, true_values=["foo"], false_values=["bar"], index_col=0
+        )
+        tm.assert_frame_equal(read_frame, expected)
+
+    def test_freeze_panes(self, path):
+        # see gh-15160
+        expected = DataFrame([[1, 2], [3, 4]], columns=["col1", "col2"])
+        expected.to_excel(path, "Sheet1", freeze_panes=(1, 1))
+
+        result = pd.read_excel(path, index_col=0)
+        tm.assert_frame_equal(result, expected)
+
+    def test_path_path_lib(self, engine, ext):
+        df = tm.makeDataFrame()
+        writer = partial(df.to_excel, engine=engine)
+
+        reader = partial(pd.read_excel, index_col=0)
+        result = tm.round_trip_pathlib(writer, reader, path=f"foo{ext}")
+        tm.assert_frame_equal(result, df)
+
+    def test_path_local_path(self, engine, ext):
+        df = tm.makeDataFrame()
+        writer = partial(df.to_excel, engine=engine)
+
+        reader = partial(pd.read_excel, index_col=0)
+        result = tm.round_trip_localpath(writer, reader, path=f"foo{ext}")
+        tm.assert_frame_equal(result, df)
+
+    def test_merged_cell_custom_objects(self, path):
+        # see GH-27006
+        mi = MultiIndex.from_tuples(
+            [
+                (pd.Period("2018"), pd.Period("2018Q1")),
+                (pd.Period("2018"), pd.Period("2018Q2")),
+            ]
+        )
+        expected = DataFrame(np.ones((2, 2), dtype="int64"), columns=mi)
+        expected.to_excel(path)
+        result = pd.read_excel(path, header=[0, 1], index_col=0)
+        # need to convert PeriodIndexes to standard Indexes for assert equal
+        expected.columns = expected.columns.set_levels(
+            [[str(i) for i in mi.levels[0]], [str(i) for i in mi.levels[1]]],
+            level=[0, 1],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [None, object])
+    def test_raise_when_saving_timezones(self, dtype, tz_aware_fixture, path):
+        # GH 27008, GH 7056
+        tz = tz_aware_fixture
+        data = pd.Timestamp("2019", tz=tz)
+        df = DataFrame([data], dtype=dtype)
+        with pytest.raises(ValueError, match="Excel does not support"):
+            df.to_excel(path)
+
+        data = data.to_pydatetime()
+        df = DataFrame([data], dtype=dtype)
+        with pytest.raises(ValueError, match="Excel does not support"):
+            df.to_excel(path)
+
+    def test_excel_duplicate_columns_with_names(self, path):
+        # GH#39695
+        df = DataFrame({"A": [0, 1], "B": [10, 11]})
+        df.to_excel(path, columns=["A", "B", "A"], index=False)
+
+        result = pd.read_excel(path)
+        expected = DataFrame([[0, 10, 0], [1, 11, 1]], columns=["A", "B", "A.1"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_if_sheet_exists_raises(self, ext):
+        # GH 40230
+        msg = "if_sheet_exists is only valid in append mode (mode='a')"
+
+        with tm.ensure_clean(ext) as f:
+            with pytest.raises(ValueError, match=re.escape(msg)):
+                ExcelWriter(f, if_sheet_exists="replace")
+
+    def test_excel_writer_empty_frame(self, engine, ext):
+        # GH#45793
+        with tm.ensure_clean(ext) as path:
+            with ExcelWriter(path, engine=engine) as writer:
+                DataFrame().to_excel(writer)
+            result = pd.read_excel(path)
+            expected = DataFrame()
+            tm.assert_frame_equal(result, expected)
+
+    def test_to_excel_empty_frame(self, engine, ext):
+        # GH#45793
+        with tm.ensure_clean(ext) as path:
+            DataFrame().to_excel(path, engine=engine)
+            result = pd.read_excel(path)
+            expected = DataFrame()
+            tm.assert_frame_equal(result, expected)
+
+
+class TestExcelWriterEngineTests:
+    @pytest.mark.parametrize(
+        "klass,ext",
+        [
+            pytest.param(_XlsxWriter, ".xlsx", marks=td.skip_if_no("xlsxwriter")),
+            pytest.param(_OpenpyxlWriter, ".xlsx", marks=td.skip_if_no("openpyxl")),
+        ],
+    )
+    def test_ExcelWriter_dispatch(self, klass, ext):
+        with tm.ensure_clean(ext) as path:
+            with ExcelWriter(path) as writer:
+                if ext == ".xlsx" and td.safe_import("xlsxwriter"):
+                    # xlsxwriter has preference over openpyxl if both installed
+                    assert isinstance(writer, _XlsxWriter)
+                else:
+                    assert isinstance(writer, klass)
+
+    def test_ExcelWriter_dispatch_raises(self):
+        with pytest.raises(ValueError, match="No engine"):
+            ExcelWriter("nothing")
+
+    def test_register_writer(self):
+        class DummyClass(ExcelWriter):
+            called_save = False
+            called_write_cells = False
+            called_sheets = False
+            _supported_extensions = ("xlsx", "xls")
+            _engine = "dummy"
+
+            def book(self):
+                pass
+
+            def _save(self):
+                type(self).called_save = True
+
+            def _write_cells(self, *args, **kwargs):
+                type(self).called_write_cells = True
+
+            @property
+            def sheets(self):
+                type(self).called_sheets = True
+
+            @classmethod
+            def assert_called_and_reset(cls):
+                assert cls.called_save
+                assert cls.called_write_cells
+                assert not cls.called_sheets
+                cls.called_save = False
+                cls.called_write_cells = False
+
+        register_writer(DummyClass)
+
+        with option_context("io.excel.xlsx.writer", "dummy"):
+            path = "something.xlsx"
+            with tm.ensure_clean(path) as filepath:
+                with ExcelWriter(filepath) as writer:
+                    assert isinstance(writer, DummyClass)
+                df = tm.makeCustomDataframe(1, 1)
+                df.to_excel(filepath)
+            DummyClass.assert_called_and_reset()
+
+        with tm.ensure_clean("something.xls") as filepath:
+            df.to_excel(filepath, engine="dummy")
+        DummyClass.assert_called_and_reset()
+
+
+@td.skip_if_no("xlrd")
+@td.skip_if_no("openpyxl")
+class TestFSPath:
+    def test_excelfile_fspath(self):
+        with tm.ensure_clean("foo.xlsx") as path:
+            df = DataFrame({"A": [1, 2]})
+            df.to_excel(path)
+            with ExcelFile(path) as xl:
+                result = os.fspath(xl)
+            assert result == path
+
+    def test_excelwriter_fspath(self):
+        with tm.ensure_clean("foo.xlsx") as path:
+            with ExcelWriter(path) as writer:
+                assert os.fspath(writer) == str(path)
+
+
+@pytest.mark.parametrize("klass", _writers.values())
+def test_subclass_attr(klass):
+    # testing that subclasses of ExcelWriter don't have public attributes (issue 49602)
+    attrs_base = {name for name in dir(ExcelWriter) if not name.startswith("_")}
+    attrs_klass = {name for name in dir(klass) if not name.startswith("_")}
+    assert not attrs_base.symmetric_difference(attrs_klass)

videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/common/test_common_basic.py

@@ -0,0 +1,864 @@
+"""
+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
+from pathlib import Path
+import sys
+
+import numpy as np
+import pytest
+
+from pandas.errors import (
+    EmptyDataError,
+    ParserError,
+    ParserWarning,
+)
+
+from pandas import (
+    DataFrame,
+    Index,
+    Timestamp,
+    compat,
+)
+import pandas._testing as tm
+
+from pandas.io.parsers import TextFileReader
+from pandas.io.parsers.c_parser_wrapper import CParserWrapper
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
+
+
+def test_override_set_noconvert_columns():
+    # see gh-17351
+    #
+    # Usecols needs to be sorted in _set_noconvert_columns based
+    # on the test_usecols_with_parse_dates test from test_usecols.py
+    class MyTextFileReader(TextFileReader):
+        def __init__(self) -> None:
+            self._currow = 0
+            self.squeeze = False
+
+    class MyCParserWrapper(CParserWrapper):
+        def _set_noconvert_columns(self):
+            if self.usecols_dtype == "integer":
+                # self.usecols is a set, which is documented as unordered
+                # but in practice, a CPython set of integers is sorted.
+                # In other implementations this assumption does not hold.
+                # The following code simulates a different order, which
+                # before GH 17351 would cause the wrong columns to be
+                # converted via the parse_dates parameter
+                self.usecols = list(self.usecols)
+                self.usecols.reverse()
+            return CParserWrapper._set_noconvert_columns(self)
+
+    data = """a,b,c,d,e
+0,1,2014-01-01,09:00,4
+0,1,2014-01-02,10:00,4"""
+
+    parse_dates = [[1, 2]]
+    cols = {
+        "a": [0, 0],
+        "c_d": [Timestamp("2014-01-01 09:00:00"), Timestamp("2014-01-02 10:00:00")],
+    }
+    expected = DataFrame(cols, columns=["c_d", "a"])
+
+    parser = MyTextFileReader()
+    parser.options = {
+        "usecols": [0, 2, 3],
+        "parse_dates": parse_dates,
+        "delimiter": ",",
+    }
+    parser.engine = "c"
+    parser._engine = MyCParserWrapper(StringIO(data), **parser.options)
+
+    result = parser.read()
+    tm.assert_frame_equal(result, expected)
+
+
+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),
+            ],
+            name="index",
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow
+def test_1000_sep(all_parsers):
+    parser = all_parsers
+    data = """A|B|C
+1|2,334|5
+10|13|10.
+"""
+    expected = DataFrame({"A": [1, 10], "B": [2334, 13], "C": [5, 10.0]})
+
+    result = parser.read_csv(StringIO(data), sep="|", thousands=",")
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow
+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)
+
+
+@xfail_pyarrow
+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
+"""
+    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),
+            ],
+            name="index",
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow
+@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
+
+    result = parser.read_csv(StringIO(data), nrows=nrows)
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_pyarrow
+@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
+
+    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)
+
+
+@xfail_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)
+
+
+@xfail_pyarrow
+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
+
+    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)
+
+
+@xfail_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"'''  # noqa:E501
+
+    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"]))
+
+
+@xfail_pyarrow
+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"
+    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)
+
+
+@xfail_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)
+
+
+@xfail_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)
+
+
+@xfail_pyarrow
+@pytest.mark.parametrize(
+    "kwargs,expected",
+    [
+        # gh-8661, gh-8679: this should ignore six lines, including
+        # lines with trailing whitespace and blank lines.
+        (
+            {
+                "header": None,
+                "delim_whitespace": True,
+                "skiprows": [0, 1, 2, 3, 5, 6],
+                "skip_blank_lines": True,
+            },
+            DataFrame([[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.
+        (
+            {
+                "delim_whitespace": True,
+                "skiprows": [1, 2, 3, 5, 6],
+                "skip_blank_lines": True,
+            },
+            DataFrame({"A": [1.0, 5.1], "B": [2.0, np.nan], "C": [4.0, 10]}),
+        ),
+    ],
+)
+def test_trailing_spaces(all_parsers, kwargs, expected):
+    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
+
+    result = parser.read_csv(StringIO(data.replace(",", "  ")), **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_raise_on_sep_with_delim_whitespace(all_parsers):
+    # see gh-6607
+    data = "a b c\n1 2 3"
+    parser = all_parsers
+
+    with pytest.raises(ValueError, match="you can only specify one"):
+        parser.read_csv(StringIO(data), sep=r"\s", delim_whitespace=True)
+
+
+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")
+
+
+@xfail_pyarrow
+@pytest.mark.parametrize("delim_whitespace", [True, False])
+def test_single_char_leading_whitespace(all_parsers, delim_whitespace):
+    # see gh-9710
+    parser = all_parsers
+    data = """\
+MyColumn
+a
+b
+a
+b\n"""
+
+    expected = DataFrame({"MyColumn": list("abab")})
+    result = parser.read_csv(
+        StringIO(data), skipinitialspace=True, delim_whitespace=delim_whitespace
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+# Skip for now, actually only one test fails though, but its tricky to xfail
+@skip_pyarrow
+@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):
+    parser = all_parsers
+    data = """\
+A,B,C
+1,2.,4.
+
+
+5.,NaN,10.0
+
+-70,.4,1
+"""
+
+    if sep == r"\s+":
+        data = data.replace(",", "  ")
+
+    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)
+
+
+@xfail_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)
+
+
+@xfail_pyarrow
+@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
+    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):
+    # see gh-15086.
+    parser = all_parsers
+    df = DataFrame({"a": [1, 2, 3]})
+
+    with tm.ensure_clean(filename) as path:
+        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)
+
+
+@xfail_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)
+
+
+@xfail_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)
+
+
+@xfail_pyarrow
+@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
+    df = parser.read_csv(StringIO(csv), header=3, nrows=nrows, skip_blank_lines=False)
+    tm.assert_frame_equal(df, ref[:nrows])
+
+
+@xfail_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"))
+
+
+@xfail_pyarrow
+def test_read_table_delim_whitespace_default_sep(all_parsers):
+    # GH: 35958
+    f = StringIO("a  b  c\n1 -2 -3\n4  5   6")
+    parser = all_parsers
+    result = parser.read_table(f, delim_whitespace=True)
+    expected = DataFrame({"a": [1, 4], "b": [-2, 5], "c": [-3, 6]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("delimiter", [",", "\t"])
+def test_read_csv_delim_whitespace_non_default_sep(all_parsers, delimiter):
+    # GH: 35958
+    f = StringIO("a  b  c\n1 -2 -3\n4  5   6")
+    parser = all_parsers
+    msg = (
+        "Specified a delimiter with both sep and "
+        "delim_whitespace=True; you can only specify one."
+    )
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(f, delim_whitespace=True, sep=delimiter)
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(f, delim_whitespace=True, delimiter=delimiter)
+
+
+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)
+
+
+@pytest.mark.parametrize("delimiter", [",", "\t"])
+def test_read_table_delim_whitespace_non_default_sep(all_parsers, delimiter):
+    # GH: 35958
+    f = StringIO("a  b  c\n1 -2 -3\n4  5   6")
+    parser = all_parsers
+    msg = (
+        "Specified a delimiter with both sep and "
+        "delim_whitespace=True; you can only specify one."
+    )
+    with pytest.raises(ValueError, match=msg):
+        parser.read_table(f, delim_whitespace=True, sep=delimiter)
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_table(f, delim_whitespace=True, delimiter=delimiter)
+
+
+@xfail_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)
+
+
+@xfail_pyarrow
+def test_encoding_surrogatepass(all_parsers):
+    # 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
+
+    with tm.ensure_clean() as path:
+        Path(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)
+
+
+@xfail_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
+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):
+    # GH48646
+    parser = all_parsers
+    prefix = "### DATA\n"
+    content = "nkey,value\ntables,rectangular\n"
+    with tm.ensure_clean() as path:
+        Path(path).write_text(prefix + content)
+        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)

videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/common/test_data_list.py

@@ -0,0 +1,87 @@
+"""
+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
+
+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)

videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/common/test_decimal.py

@@ -0,0 +1,63 @@
+"""
+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
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+
+
+@xfail_pyarrow
+@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]})
+
+    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)

videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/common/test_file_buffer_url.py

@@ -0,0 +1,423 @@
+"""
+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 pytest
+
+from pandas.errors import (
+    EmptyDataError,
+    ParserError,
+)
+import pandas.util._test_decorators as td
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+# TODO(1.4) Please xfail individual tests at release time
+# instead of skip
+pytestmark = pytest.mark.usefixtures("pyarrow_skip")
+
+
+@pytest.mark.network
+@tm.network(
+    url=(
+        "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
+        "pandas/tests/io/parser/data/salaries.csv"
+    ),
+    check_before_test=True,
+)
+def test_url(all_parsers, csv_dir_path):
+    parser = all_parsers
+    kwargs = {"sep": "\t"}
+
+    url = (
+        "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
+        "pandas/tests/io/parser/data/salaries.csv"
+    )
+    url_result = parser.read_csv(url, **kwargs)
+
+    local_path = os.path.join(csv_dir_path, "salaries.csv")
+    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()))
+
+
+def test_path_path_lib(all_parsers):
+    parser = all_parsers
+    df = tm.makeDataFrame()
+    result = tm.round_trip_pathlib(df.to_csv, lambda p: parser.read_csv(p, index_col=0))
+    tm.assert_frame_equal(df, result)
+
+
+def test_path_local_path(all_parsers):
+    parser = all_parsers
+    df = tm.makeDataFrame()
+    result = tm.round_trip_localpath(
+        df.to_csv, lambda p: parser.read_csv(p, index_col=0)
+    )
+    tm.assert_frame_equal(df, result)
+
+
+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
+
+
+@td.skip_if_windows  # os.chmod does not work in windows
+def test_no_permission(all_parsers):
+    # GH 23784
+    parser = all_parsers
+
+    msg = r"\[Errno 13\]"
+    with tm.ensure_clean() as path:
+        os.chmod(path, 0)  # make file unreadable
+
+        # verify that this process cannot open the file (not running as sudo)
+        try:
+            with open(path):
+                pass
+            pytest.skip("Running as sudo.")
+        except PermissionError:
+            pass
+
+        with pytest.raises(PermissionError, match=msg) as e:
+            parser.read_csv(path)
+        assert path == 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):
+    # see gh-10728, gh-10548
+    parser = all_parsers
+
+    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):
+    # see gh-13398
+    parser = all_parsers
+    data = "0 0"
+
+    with tm.ensure_clean(mode="w+", return_filelike=True) as new_file:
+        new_file.write(data)
+        new_file.flush()
+        new_file.seek(0)
+
+        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):
+    # 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"
+
+    with tm.ensure_clean(path) as path:
+        with open(path, "wb") as f:
+            f.write(data)
+
+        result = parser.read_csv(path)
+        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) 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):
+    """
+    Support memory map for compressed files.
+
+    GH 37621
+    """
+    parser = all_parsers
+    expected = DataFrame({"a": [1], "b": [2]})
+
+    with tm.ensure_clean() as path:
+        expected.to_csv(path, index=False, compression=compression)
+
+        tm.assert_frame_equal(
+            parser.read_csv(path, memory_map=True, compression=compression),
+            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")
+
+    reader = parser.read_csv(path, chunksize=1)
+    assert not reader.handles.handle.closed
+    try:
+        with reader:
+            next(reader)
+            assert False
+    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")) as path:
+        reader = parser.read_csv(path, chunksize=1)
+        assert not reader.handles.handle.closed
+        try:
+            with reader:
+                next(reader)
+                assert False
+        except AssertionError:
+            assert not reader.handles.handle.closed
+
+
+def test_file_descriptor_leak(all_parsers, using_copy_on_write):
+    # GH 31488
+    parser = all_parsers
+    with tm.ensure_clean() as path:
+        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"]}
+    )
+
+    result = parser.read_csv(mmap_file, memory_map=True)
+    tm.assert_frame_equal(result, expected)

videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/common/test_index.py

@@ -0,0 +1,299 @@
+"""
+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
+
+xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
+
+# GH#43650: Some expected failures with the pyarrow engine can occasionally
+# cause a deadlock instead, so we skip these instead of xfailing
+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(all_parsers, index_col):
+    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)
+
+
+@xfail_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
+@pytest.mark.parametrize(
+    "data,expected,header",
+    [
+        ("a,b", DataFrame(columns=["a", "b"]), [0]),
+        (
+            "a,b\nc,d",
+            DataFrame(columns=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, expected, header, round_trip):
+    # see gh-14545
+    parser = all_parsers
+    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
+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)
+
+
+@xfail_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)
+
+
+@xfail_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),
+            ]
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@xfail_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)
+
+
+@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)
+
+
+@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)

videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/common/test_ints.py

@@ -0,0 +1,215 @@
+"""
+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
+
+# GH#43650: Some expected failures with the pyarrow engine can occasionally
+# cause a deadlock instead, so we skip these instead of xfailing
+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",
+            {},
+            DataFrame([[True, 1], [False, 2], [True, 3]], columns=["A", "B"]),
+        ),
+        (
+            "A,B\nYES,1\nno,2\nyes,3\nNo,3\nYes,3",
+            {"true_values": ["yes", "Yes", "YES"], "false_values": ["no", "NO", "No"]},
+            DataFrame(
+                [[True, 1], [False, 2], [True, 3], [False, 3], [True, 3]],
+                columns=["A", "B"],
+            ),
+        ),
+        (
+            "A,B\nTRUE,1\nFALSE,2\nTRUE,3",
+            {},
+            DataFrame([[True, 1], [False, 2], [True, 3]], columns=["A", "B"]),
+        ),
+        (
+            "A,B\nfoo,bar\nbar,foo",
+            {"true_values": ["foo"], "false_values": ["bar"]},
+            DataFrame([[True, False], [False, True]], columns=["A", "B"]),
+        ),
+    ],
+)
+def test_parse_bool(all_parsers, data, kwargs, expected):
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), **kwargs)
+    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)
+
+
+@skip_pyarrow  # Flaky
+@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
+
+    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)
+
+
+@skip_pyarrow
+@pytest.mark.parametrize("conv", [None, np.int64, np.uint64])
+def test_int64_overflow(all_parsers, conv):
+    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.
+        result = parser.read_csv(StringIO(data))
+        expected = DataFrame(
+            [
+                "00013007854817840016671868",
+                "00013007854817840016749251",
+                "00013007854817840016754630",
+                "00013007854817840016781876",
+                "00013007854817840017028824",
+                "00013007854817840017963235",
+                "00013007854817840018860166",
+            ],
+            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 = (
+            "(Python int too large to convert to C long)|"
+            "(long too big to convert)|"
+            "(int too big to convert)"
+        )
+
+        with pytest.raises(OverflowError, match=msg):
+            parser.read_csv(StringIO(data), converters={"ID": conv})
+
+
+@skip_pyarrow
+@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 string.
+    parser = all_parsers
+    result = parser.read_csv(StringIO(str(val)), header=None)
+
+    expected = DataFrame([val])
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+@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):
+    # These numbers fall just outside the int64-uint64
+    # range, so they should be parsed as string.
+    parser = all_parsers
+    result = parser.read_csv(StringIO(str(val)), header=None)
+
+    expected = DataFrame([str(val)])
+    tm.assert_frame_equal(result, expected)
+
+
+@skip_pyarrow
+@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)

videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/common/test_iterator.py

@@ -0,0 +1,108 @@
+"""
+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.usefixtures("pyarrow_skip")
+
+
+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)
+    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
+"""
+
+    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
+"""
+
+    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)
+
+
+@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"
+
+    with pytest.raises(ValueError, match=msg):
+        with parser.read_csv(StringIO(data), skipfooter=1, **kwargs) as _:
+            pass
+
+
+def test_iteration_open_handle(all_parsers):
+    parser = all_parsers
+    kwargs = {"header": None}
+
+    with tm.ensure_clean() as path:
+        with open(path, "w") as f:
+            f.write("AAA\nBBB\nCCC\nDDD\nEEE\nFFF\nGGG")
+
+        with open(path) 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)

videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/common/test_read_errors.py

@@ -0,0 +1,274 @@
+"""
+Tests that work on both the Python and C 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 warnings
+
+import numpy as np
+import pytest
+
+from pandas.compat import PY311
+from pandas.errors import (
+    EmptyDataError,
+    ParserError,
+)
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+pytestmark = 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
+
+    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"
+    with pytest.raises(ParserError, 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
+    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)
+
+
+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"])
+
+
+@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, capsys):
+    # 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)
+
+    captured = capsys.readouterr()
+    assert captured.err == ""
+
+
+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"
+    with pytest.raises(ParserError, match=msg):
+        parser.read_csv(StringIO(data), on_bad_lines="error")
+
+
+def test_warn_bad_lines(all_parsers, capsys):
+    # 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="warn")
+    tm.assert_frame_equal(result, expected)
+
+    captured = capsys.readouterr()
+    assert "Skipping line 3" in captured.err
+    assert "Skipping line 5" in captured.err
+
+
+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"
+
+    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 == "c" or (parser.engine == "python" and PY311):
+        if parser.engine == "python" and PY311:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason="In Python 3.11, 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:
+        msg = "NULL byte detected"
+        with pytest.raises(ParserError, match=msg):
+            parser.read_csv(StringIO(data), names=names)
+
+
+def test_open_file(request, all_parsers):
+    # GH 39024
+    parser = all_parsers
+    if parser.engine == "c":
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason=f"{parser.engine} engine does not support sep=None "
+                f"with delim_whitespace=False"
+            )
+        )
+
+    with tm.ensure_clean() as path:
+        file = Path(path)
+        file.write_bytes(b"\xe4\na\n1")
+
+        with warnings.catch_warnings(record=True) as record:
+            # should not trigger a ResourceWarning
+            warnings.simplefilter("always", category=ResourceWarning)
+            with pytest.raises(csv.Error, match="Could not determine delimiter"):
+                parser.read_csv(file, sep=None, encoding_errors="replace")
+            assert len(record) == 0, record[0].message
+
+
+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."
+        )
+
+    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, capsys):
+    # 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})
+
+    result = parser.read_csv(StringIO(data), on_bad_lines="warn")
+    tm.assert_frame_equal(result, expected)
+
+    captured = capsys.readouterr()
+    if parser.engine == "c":
+        warn = """Skipping line 3: expected 2 fields, saw 3
+Skipping line 4: expected 2 fields, saw 3
+
+"""
+    else:
+        warn = """Skipping line 3: Expected 2 fields in line 3, saw 3
+Skipping line 4: Expected 2 fields in line 4, saw 3
+"""
+    assert captured.err == warn