Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/pandas/tests/construction/test_extract_array.py

@@ -0,0 +1,18 @@
+from pandas import Index
+import pandas._testing as tm
+from pandas.core.construction import extract_array
+
+
+def test_extract_array_rangeindex():
+    ri = Index(range(5))
+
+    expected = ri._values
+    res = extract_array(ri, extract_numpy=True, extract_range=True)
+    tm.assert_numpy_array_equal(res, expected)
+    res = extract_array(ri, extract_numpy=False, extract_range=True)
+    tm.assert_numpy_array_equal(res, expected)
+
+    res = extract_array(ri, extract_numpy=True, extract_range=False)
+    tm.assert_index_equal(res, ri)
+    res = extract_array(ri, extract_numpy=False, extract_range=False)
+    tm.assert_index_equal(res, ri)

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

@@ -0,0 +1,242 @@
+import shlex
+import subprocess
+import time
+import uuid
+
+import pytest
+
+from pandas.compat import (
+    is_ci_environment,
+    is_platform_arm,
+    is_platform_mac,
+    is_platform_windows,
+)
+import pandas.util._test_decorators as td
+
+import pandas.io.common as icom
+from pandas.io.parsers import read_csv
+
+
+@pytest.fixture
+def compression_to_extension():
+    return {value: key for key, value in icom.extension_to_compression.items()}
+
+
+@pytest.fixture
+def tips_file(datapath):
+    """Path to the tips dataset"""
+    return datapath("io", "data", "csv", "tips.csv")
+
+
+@pytest.fixture
+def jsonl_file(datapath):
+    """Path to a JSONL dataset"""
+    return datapath("io", "parser", "data", "items.jsonl")
+
+
+@pytest.fixture
+def salaries_table(datapath):
+    """DataFrame with the salaries dataset"""
+    return read_csv(datapath("io", "parser", "data", "salaries.csv"), sep="\t")
+
+
+@pytest.fixture
+def feather_file(datapath):
+    return datapath("io", "data", "feather", "feather-0_3_1.feather")
+
+
+@pytest.fixture
+def xml_file(datapath):
+    return datapath("io", "data", "xml", "books.xml")
+
+
+@pytest.fixture
+def s3_base(worker_id, monkeypatch):
+    """
+    Fixture for mocking S3 interaction.
+
+    Sets up moto server in separate process locally
+    Return url for motoserver/moto CI service
+    """
+    pytest.importorskip("s3fs")
+    pytest.importorskip("boto3")
+
+    # temporary workaround as moto fails for botocore >= 1.11 otherwise,
+    # see https://github.com/spulec/moto/issues/1924 & 1952
+    monkeypatch.setenv("AWS_ACCESS_KEY_ID", "foobar_key")
+    monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "foobar_secret")
+    if is_ci_environment():
+        if is_platform_arm() or is_platform_mac() or is_platform_windows():
+            # NOT RUN on Windows/macOS/ARM, only Ubuntu
+            # - subprocess in CI can cause timeouts
+            # - GitHub Actions do not support
+            #   container services for the above OSs
+            # - CircleCI will probably hit the Docker rate pull limit
+            pytest.skip(
+                "S3 tests do not have a corresponding service in "
+                "Windows, macOS or ARM platforms"
+            )
+        else:
+            # set in .github/workflows/unit-tests.yml
+            yield "http://localhost:5000"
+    else:
+        requests = pytest.importorskip("requests")
+        pytest.importorskip("moto")
+        pytest.importorskip("flask")  # server mode needs flask too
+
+        # Launching moto in server mode, i.e., as a separate process
+        # with an S3 endpoint on localhost
+
+        worker_id = "5" if worker_id == "master" else worker_id.lstrip("gw")
+        endpoint_port = f"555{worker_id}"
+        endpoint_uri = f"http://127.0.0.1:{endpoint_port}/"
+
+        # pipe to null to avoid logging in terminal
+        with subprocess.Popen(
+            shlex.split(f"moto_server s3 -p {endpoint_port}"),
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        ) as proc:
+            timeout = 5
+            while timeout > 0:
+                try:
+                    # OK to go once server is accepting connections
+                    r = requests.get(endpoint_uri)
+                    if r.ok:
+                        break
+                except Exception:
+                    pass
+                timeout -= 0.1
+                time.sleep(0.1)
+            yield endpoint_uri
+
+            proc.terminate()
+
+
+@pytest.fixture
+def s3so(s3_base):
+    return {"client_kwargs": {"endpoint_url": s3_base}}
+
+
+@pytest.fixture
+def s3_resource(s3_base):
+    import boto3
+
+    s3 = boto3.resource("s3", endpoint_url=s3_base)
+    return s3
+
+
+@pytest.fixture
+def s3_public_bucket(s3_resource):
+    bucket = s3_resource.Bucket(f"pandas-test-{uuid.uuid4()}")
+    bucket.create()
+    yield bucket
+    bucket.objects.delete()
+    bucket.delete()
+
+
+@pytest.fixture
+def s3_public_bucket_with_data(
+    s3_public_bucket, tips_file, jsonl_file, feather_file, xml_file
+):
+    """
+    The following datasets
+    are loaded.
+
+    - tips.csv
+    - tips.csv.gz
+    - tips.csv.bz2
+    - items.jsonl
+    """
+    test_s3_files = [
+        ("tips#1.csv", tips_file),
+        ("tips.csv", tips_file),
+        ("tips.csv.gz", tips_file + ".gz"),
+        ("tips.csv.bz2", tips_file + ".bz2"),
+        ("items.jsonl", jsonl_file),
+        ("simple_dataset.feather", feather_file),
+        ("books.xml", xml_file),
+    ]
+    for s3_key, file_name in test_s3_files:
+        with open(file_name, "rb") as f:
+            s3_public_bucket.put_object(Key=s3_key, Body=f)
+    return s3_public_bucket
+
+
+@pytest.fixture
+def s3_private_bucket(s3_resource):
+    bucket = s3_resource.Bucket(f"cant_get_it-{uuid.uuid4()}")
+    bucket.create(ACL="private")
+    yield bucket
+    bucket.objects.delete()
+    bucket.delete()
+
+
+@pytest.fixture
+def s3_private_bucket_with_data(
+    s3_private_bucket, tips_file, jsonl_file, feather_file, xml_file
+):
+    """
+    The following datasets
+    are loaded.
+
+    - tips.csv
+    - tips.csv.gz
+    - tips.csv.bz2
+    - items.jsonl
+    """
+    test_s3_files = [
+        ("tips#1.csv", tips_file),
+        ("tips.csv", tips_file),
+        ("tips.csv.gz", tips_file + ".gz"),
+        ("tips.csv.bz2", tips_file + ".bz2"),
+        ("items.jsonl", jsonl_file),
+        ("simple_dataset.feather", feather_file),
+        ("books.xml", xml_file),
+    ]
+    for s3_key, file_name in test_s3_files:
+        with open(file_name, "rb") as f:
+            s3_private_bucket.put_object(Key=s3_key, Body=f)
+    return s3_private_bucket
+
+
+_compression_formats_params = [
+    (".no_compress", None),
+    ("", None),
+    (".gz", "gzip"),
+    (".GZ", "gzip"),
+    (".bz2", "bz2"),
+    (".BZ2", "bz2"),
+    (".zip", "zip"),
+    (".ZIP", "zip"),
+    (".xz", "xz"),
+    (".XZ", "xz"),
+    pytest.param((".zst", "zstd"), marks=td.skip_if_no("zstandard")),
+    pytest.param((".ZST", "zstd"), marks=td.skip_if_no("zstandard")),
+]
+
+
+@pytest.fixture(params=_compression_formats_params[1:])
+def compression_format(request):
+    return request.param
+
+
+@pytest.fixture(params=_compression_formats_params)
+def compression_ext(request):
+    return request.param[0]
+
+
+@pytest.fixture(
+    params=[
+        "python",
+        pytest.param("pyarrow", marks=td.skip_if_no("pyarrow")),
+    ]
+)
+def string_storage(request):
+    """
+    Parametrized fixture for pd.options.mode.string_storage.
+
+    * 'python'
+    * 'pyarrow'
+    """
+    return request.param

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,423 @@
+from textwrap import dedent
+
+import numpy as np
+import pytest
+
+from pandas.errors import (
+    PyperclipException,
+    PyperclipWindowsException,
+)
+
+import pandas as pd
+from pandas import (
+    NA,
+    DataFrame,
+    Series,
+    get_option,
+    read_clipboard,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    ArrowStringArray,
+    StringArray,
+)
+
+from pandas.io.clipboard import (
+    CheckedCall,
+    _stringifyText,
+    init_qt_clipboard,
+)
+
+
+def build_kwargs(sep, excel):
+    kwargs = {}
+    if excel != "default":
+        kwargs["excel"] = excel
+    if sep != "default":
+        kwargs["sep"] = sep
+    return kwargs
+
+
+@pytest.fixture(
+    params=[
+        "delims",
+        "utf8",
+        "utf16",
+        "string",
+        "long",
+        "nonascii",
+        "colwidth",
+        "mixed",
+        "float",
+        "int",
+    ]
+)
+def df(request):
+    data_type = request.param
+
+    if data_type == "delims":
+        return DataFrame({"a": ['"a,\t"b|c', "d\tef`"], "b": ["hi'j", "k''lm"]})
+    elif data_type == "utf8":
+        return DataFrame({"a": ["µasd", "Ωœ∑`"], "b": ["øπ∆˚¬", "œ∑`®"]})
+    elif data_type == "utf16":
+        return DataFrame(
+            {"a": ["\U0001f44d\U0001f44d", "\U0001f44d\U0001f44d"], "b": ["abc", "def"]}
+        )
+    elif data_type == "string":
+        return DataFrame(
+            np.array([f"i-{i}" for i in range(15)]).reshape(5, 3), columns=list("abc")
+        )
+    elif data_type == "long":
+        max_rows = get_option("display.max_rows")
+        return DataFrame(
+            np.random.default_rng(2).integers(0, 10, size=(max_rows + 1, 3)),
+            columns=list("abc"),
+        )
+    elif data_type == "nonascii":
+        return DataFrame({"en": "in English".split(), "es": "en español".split()})
+    elif data_type == "colwidth":
+        _cw = get_option("display.max_colwidth") + 1
+        return DataFrame(
+            np.array(["x" * _cw for _ in range(15)]).reshape(5, 3), columns=list("abc")
+        )
+    elif data_type == "mixed":
+        return DataFrame(
+            {
+                "a": np.arange(1.0, 6.0) + 0.01,
+                "b": np.arange(1, 6).astype(np.int64),
+                "c": list("abcde"),
+            }
+        )
+    elif data_type == "float":
+        return DataFrame(np.random.default_rng(2).random((5, 3)), columns=list("abc"))
+    elif data_type == "int":
+        return DataFrame(
+            np.random.default_rng(2).integers(0, 10, (5, 3)), columns=list("abc")
+        )
+    else:
+        raise ValueError
+
+
+@pytest.fixture
+def mock_ctypes(monkeypatch):
+    """
+    Mocks WinError to help with testing the clipboard.
+    """
+
+    def _mock_win_error():
+        return "Window Error"
+
+    # Set raising to False because WinError won't exist on non-windows platforms
+    with monkeypatch.context() as m:
+        m.setattr("ctypes.WinError", _mock_win_error, raising=False)
+        yield
+
+
+@pytest.mark.usefixtures("mock_ctypes")
+def test_checked_call_with_bad_call(monkeypatch):
+    """
+    Give CheckCall a function that returns a falsey value and
+    mock get_errno so it returns false so an exception is raised.
+    """
+
+    def _return_false():
+        return False
+
+    monkeypatch.setattr("pandas.io.clipboard.get_errno", lambda: True)
+    msg = f"Error calling {_return_false.__name__} \\(Window Error\\)"
+
+    with pytest.raises(PyperclipWindowsException, match=msg):
+        CheckedCall(_return_false)()
+
+
+@pytest.mark.usefixtures("mock_ctypes")
+def test_checked_call_with_valid_call(monkeypatch):
+    """
+    Give CheckCall a function that returns a truthy value and
+    mock get_errno so it returns true so an exception is not raised.
+    The function should return the results from _return_true.
+    """
+
+    def _return_true():
+        return True
+
+    monkeypatch.setattr("pandas.io.clipboard.get_errno", lambda: False)
+
+    # Give CheckedCall a callable that returns a truthy value s
+    checked_call = CheckedCall(_return_true)
+    assert checked_call() is True
+
+
+@pytest.mark.parametrize(
+    "text",
+    [
+        "String_test",
+        True,
+        1,
+        1.0,
+        1j,
+    ],
+)
+def test_stringify_text(text):
+    valid_types = (str, int, float, bool)
+
+    if isinstance(text, valid_types):
+        result = _stringifyText(text)
+        assert result == str(text)
+    else:
+        msg = (
+            "only str, int, float, and bool values "
+            f"can be copied to the clipboard, not {type(text).__name__}"
+        )
+        with pytest.raises(PyperclipException, match=msg):
+            _stringifyText(text)
+
+
+@pytest.fixture
+def set_pyqt_clipboard(monkeypatch):
+    qt_cut, qt_paste = init_qt_clipboard()
+    with monkeypatch.context() as m:
+        m.setattr(pd.io.clipboard, "clipboard_set", qt_cut)
+        m.setattr(pd.io.clipboard, "clipboard_get", qt_paste)
+        yield
+
+
+@pytest.fixture
+def clipboard(qapp):
+    clip = qapp.clipboard()
+    yield clip
+    clip.clear()
+
+
+@pytest.mark.single_cpu
+@pytest.mark.clipboard
+@pytest.mark.usefixtures("set_pyqt_clipboard")
+@pytest.mark.usefixtures("clipboard")
+class TestClipboard:
+    # Test that default arguments copy as tab delimited
+    # Test that explicit delimiters are respected
+    @pytest.mark.parametrize("sep", [None, "\t", ",", "|"])
+    @pytest.mark.parametrize("encoding", [None, "UTF-8", "utf-8", "utf8"])
+    def test_round_trip_frame_sep(self, df, sep, encoding):
+        df.to_clipboard(excel=None, sep=sep, encoding=encoding)
+        result = read_clipboard(sep=sep or "\t", index_col=0, encoding=encoding)
+        tm.assert_frame_equal(df, result)
+
+    # Test white space separator
+    def test_round_trip_frame_string(self, df):
+        df.to_clipboard(excel=False, sep=None)
+        result = read_clipboard()
+        assert df.to_string() == result.to_string()
+        assert df.shape == result.shape
+
+    # Two character separator is not supported in to_clipboard
+    # Test that multi-character separators are not silently passed
+    def test_excel_sep_warning(self, df):
+        with tm.assert_produces_warning(
+            UserWarning,
+            match="to_clipboard in excel mode requires a single character separator.",
+            check_stacklevel=False,
+        ):
+            df.to_clipboard(excel=True, sep=r"\t")
+
+    # Separator is ignored when excel=False and should produce a warning
+    def test_copy_delim_warning(self, df):
+        with tm.assert_produces_warning():
+            df.to_clipboard(excel=False, sep="\t")
+
+    # Tests that the default behavior of to_clipboard is tab
+    # delimited and excel="True"
+    @pytest.mark.parametrize("sep", ["\t", None, "default"])
+    @pytest.mark.parametrize("excel", [True, None, "default"])
+    def test_clipboard_copy_tabs_default(self, sep, excel, df, clipboard):
+        kwargs = build_kwargs(sep, excel)
+        df.to_clipboard(**kwargs)
+        assert clipboard.text() == df.to_csv(sep="\t")
+
+    # Tests reading of white space separated tables
+    @pytest.mark.parametrize("sep", [None, "default"])
+    def test_clipboard_copy_strings(self, sep, df):
+        kwargs = build_kwargs(sep, False)
+        df.to_clipboard(**kwargs)
+        result = read_clipboard(sep=r"\s+")
+        assert result.to_string() == df.to_string()
+        assert df.shape == result.shape
+
+    def test_read_clipboard_infer_excel(self, clipboard):
+        # gh-19010: avoid warnings
+        clip_kwargs = {"engine": "python"}
+
+        text = dedent(
+            """
+            John James\tCharlie Mingus
+            1\t2
+            4\tHarry Carney
+            """.strip()
+        )
+        clipboard.setText(text)
+        df = read_clipboard(**clip_kwargs)
+
+        # excel data is parsed correctly
+        assert df.iloc[1, 1] == "Harry Carney"
+
+        # having diff tab counts doesn't trigger it
+        text = dedent(
+            """
+            a\t b
+            1  2
+            3  4
+            """.strip()
+        )
+        clipboard.setText(text)
+        res = read_clipboard(**clip_kwargs)
+
+        text = dedent(
+            """
+            a  b
+            1  2
+            3  4
+            """.strip()
+        )
+        clipboard.setText(text)
+        exp = read_clipboard(**clip_kwargs)
+
+        tm.assert_frame_equal(res, exp)
+
+    def test_infer_excel_with_nulls(self, clipboard):
+        # GH41108
+        text = "col1\tcol2\n1\tred\n\tblue\n2\tgreen"
+
+        clipboard.setText(text)
+        df = read_clipboard()
+        df_expected = DataFrame(
+            data={"col1": [1, None, 2], "col2": ["red", "blue", "green"]}
+        )
+
+        # excel data is parsed correctly
+        tm.assert_frame_equal(df, df_expected)
+
+    @pytest.mark.parametrize(
+        "multiindex",
+        [
+            (  # Can't use `dedent` here as it will remove the leading `\t`
+                "\n".join(
+                    [
+                        "\t\t\tcol1\tcol2",
+                        "A\t0\tTrue\t1\tred",
+                        "A\t1\tTrue\t\tblue",
+                        "B\t0\tFalse\t2\tgreen",
+                    ]
+                ),
+                [["A", "A", "B"], [0, 1, 0], [True, True, False]],
+            ),
+            (
+                "\n".join(
+                    ["\t\tcol1\tcol2", "A\t0\t1\tred", "A\t1\t\tblue", "B\t0\t2\tgreen"]
+                ),
+                [["A", "A", "B"], [0, 1, 0]],
+            ),
+        ],
+    )
+    def test_infer_excel_with_multiindex(self, clipboard, multiindex):
+        # GH41108
+
+        clipboard.setText(multiindex[0])
+        df = read_clipboard()
+        df_expected = DataFrame(
+            data={"col1": [1, None, 2], "col2": ["red", "blue", "green"]},
+            index=multiindex[1],
+        )
+
+        # excel data is parsed correctly
+        tm.assert_frame_equal(df, df_expected)
+
+    def test_invalid_encoding(self, df):
+        msg = "clipboard only supports utf-8 encoding"
+        # test case for testing invalid encoding
+        with pytest.raises(ValueError, match=msg):
+            df.to_clipboard(encoding="ascii")
+        with pytest.raises(NotImplementedError, match=msg):
+            read_clipboard(encoding="ascii")
+
+    @pytest.mark.parametrize("data", ["\U0001f44d...", "Ωœ∑`...", "abcd..."])
+    def test_raw_roundtrip(self, data):
+        # PR #25040 wide unicode wasn't copied correctly on PY3 on windows
+        df = DataFrame({"data": [data]})
+        df.to_clipboard()
+        result = read_clipboard()
+        tm.assert_frame_equal(df, result)
+
+    @pytest.mark.parametrize("engine", ["c", "python"])
+    def test_read_clipboard_dtype_backend(
+        self, clipboard, string_storage, dtype_backend, engine
+    ):
+        # GH#50502
+        if string_storage == "pyarrow" or dtype_backend == "pyarrow":
+            pa = pytest.importorskip("pyarrow")
+
+        if string_storage == "python":
+            string_array = StringArray(np.array(["x", "y"], dtype=np.object_))
+            string_array_na = StringArray(np.array(["x", NA], dtype=np.object_))
+
+        elif dtype_backend == "pyarrow" and engine != "c":
+            pa = pytest.importorskip("pyarrow")
+            from pandas.arrays import ArrowExtensionArray
+
+            string_array = ArrowExtensionArray(pa.array(["x", "y"]))
+            string_array_na = ArrowExtensionArray(pa.array(["x", None]))
+
+        else:
+            string_array = ArrowStringArray(pa.array(["x", "y"]))
+            string_array_na = ArrowStringArray(pa.array(["x", None]))
+
+        text = """a,b,c,d,e,f,g,h,i
+x,1,4.0,x,2,4.0,,True,False
+y,2,5.0,,,,,False,"""
+        clipboard.setText(text)
+
+        with pd.option_context("mode.string_storage", string_storage):
+            result = read_clipboard(sep=",", dtype_backend=dtype_backend, engine=engine)
+
+        expected = DataFrame(
+            {
+                "a": string_array,
+                "b": Series([1, 2], dtype="Int64"),
+                "c": Series([4.0, 5.0], dtype="Float64"),
+                "d": string_array_na,
+                "e": Series([2, NA], dtype="Int64"),
+                "f": Series([4.0, NA], dtype="Float64"),
+                "g": Series([NA, NA], dtype="Int64"),
+                "h": Series([True, False], dtype="boolean"),
+                "i": Series([False, NA], dtype="boolean"),
+            }
+        )
+        if dtype_backend == "pyarrow":
+            from pandas.arrays import ArrowExtensionArray
+
+            expected = DataFrame(
+                {
+                    col: ArrowExtensionArray(pa.array(expected[col], from_pandas=True))
+                    for col in expected.columns
+                }
+            )
+            expected["g"] = ArrowExtensionArray(pa.array([None, None]))
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_invalid_dtype_backend(self):
+        msg = (
+            "dtype_backend numpy is invalid, only 'numpy_nullable' and "
+            "'pyarrow' are allowed."
+        )
+        with pytest.raises(ValueError, match=msg):
+            read_clipboard(dtype_backend="numpy")
+
+    def test_to_clipboard_pos_args_deprecation(self):
+        # GH-54229
+        df = DataFrame({"a": [1, 2, 3]})
+        msg = (
+            r"Starting with pandas version 3.0 all arguments of to_clipboard "
+            r"will be keyword-only."
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            df.to_clipboard(True, None)

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

@@ -0,0 +1,650 @@
+"""
+Tests for the pandas.io.common functionalities
+"""
+import codecs
+import errno
+from functools import partial
+from io import (
+    BytesIO,
+    StringIO,
+    UnsupportedOperation,
+)
+import mmap
+import os
+from pathlib import Path
+import pickle
+import tempfile
+
+import numpy as np
+import pytest
+
+from pandas.compat import is_platform_windows
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+
+import pandas.io.common as icom
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+class CustomFSPath:
+    """For testing fspath on unknown objects"""
+
+    def __init__(self, path) -> None:
+        self.path = path
+
+    def __fspath__(self):
+        return self.path
+
+
+# Functions that consume a string path and return a string or path-like object
+path_types = [str, CustomFSPath, Path]
+
+try:
+    from py.path import local as LocalPath
+
+    path_types.append(LocalPath)
+except ImportError:
+    pass
+
+HERE = os.path.abspath(os.path.dirname(__file__))
+
+
+# https://github.com/cython/cython/issues/1720
+class TestCommonIOCapabilities:
+    data1 = """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
+"""
+
+    def test_expand_user(self):
+        filename = "~/sometest"
+        expanded_name = icom._expand_user(filename)
+
+        assert expanded_name != filename
+        assert os.path.isabs(expanded_name)
+        assert os.path.expanduser(filename) == expanded_name
+
+    def test_expand_user_normal_path(self):
+        filename = "/somefolder/sometest"
+        expanded_name = icom._expand_user(filename)
+
+        assert expanded_name == filename
+        assert os.path.expanduser(filename) == expanded_name
+
+    def test_stringify_path_pathlib(self):
+        rel_path = icom.stringify_path(Path("."))
+        assert rel_path == "."
+        redundant_path = icom.stringify_path(Path("foo//bar"))
+        assert redundant_path == os.path.join("foo", "bar")
+
+    @td.skip_if_no("py.path")
+    def test_stringify_path_localpath(self):
+        path = os.path.join("foo", "bar")
+        abs_path = os.path.abspath(path)
+        lpath = LocalPath(path)
+        assert icom.stringify_path(lpath) == abs_path
+
+    def test_stringify_path_fspath(self):
+        p = CustomFSPath("foo/bar.csv")
+        result = icom.stringify_path(p)
+        assert result == "foo/bar.csv"
+
+    def test_stringify_file_and_path_like(self):
+        # GH 38125: do not stringify file objects that are also path-like
+        fsspec = pytest.importorskip("fsspec")
+        with tm.ensure_clean() as path:
+            with fsspec.open(f"file://{path}", mode="wb") as fsspec_obj:
+                assert fsspec_obj == icom.stringify_path(fsspec_obj)
+
+    @pytest.mark.parametrize("path_type", path_types)
+    def test_infer_compression_from_path(self, compression_format, path_type):
+        extension, expected = compression_format
+        path = path_type("foo/bar.csv" + extension)
+        compression = icom.infer_compression(path, compression="infer")
+        assert compression == expected
+
+    @pytest.mark.parametrize("path_type", [str, CustomFSPath, Path])
+    def test_get_handle_with_path(self, path_type):
+        # ignore LocalPath: it creates strange paths: /absolute/~/sometest
+        with tempfile.TemporaryDirectory(dir=Path.home()) as tmp:
+            filename = path_type("~/" + Path(tmp).name + "/sometest")
+            with icom.get_handle(filename, "w") as handles:
+                assert Path(handles.handle.name).is_absolute()
+                assert os.path.expanduser(filename) == handles.handle.name
+
+    def test_get_handle_with_buffer(self):
+        with StringIO() as input_buffer:
+            with icom.get_handle(input_buffer, "r") as handles:
+                assert handles.handle == input_buffer
+            assert not input_buffer.closed
+        assert input_buffer.closed
+
+    # Test that BytesIOWrapper(get_handle) returns correct amount of bytes every time
+    def test_bytesiowrapper_returns_correct_bytes(self):
+        # Test latin1, ucs-2, and ucs-4 chars
+        data = """a,b,c
+1,2,3
+©,®,®
+Look,a snake,🐍"""
+        with icom.get_handle(StringIO(data), "rb", is_text=False) as handles:
+            result = b""
+            chunksize = 5
+            while True:
+                chunk = handles.handle.read(chunksize)
+                # Make sure each chunk is correct amount of bytes
+                assert len(chunk) <= chunksize
+                if len(chunk) < chunksize:
+                    # Can be less amount of bytes, but only at EOF
+                    # which happens when read returns empty
+                    assert len(handles.handle.read()) == 0
+                    result += chunk
+                    break
+                result += chunk
+            assert result == data.encode("utf-8")
+
+    # Test that pyarrow can handle a file opened with get_handle
+    def test_get_handle_pyarrow_compat(self):
+        pa_csv = pytest.importorskip("pyarrow.csv")
+
+        # Test latin1, ucs-2, and ucs-4 chars
+        data = """a,b,c
+1,2,3
+©,®,®
+Look,a snake,🐍"""
+        expected = pd.DataFrame(
+            {"a": ["1", "©", "Look"], "b": ["2", "®", "a snake"], "c": ["3", "®", "🐍"]}
+        )
+        s = StringIO(data)
+        with icom.get_handle(s, "rb", is_text=False) as handles:
+            df = pa_csv.read_csv(handles.handle).to_pandas()
+            tm.assert_frame_equal(df, expected)
+            assert not s.closed
+
+    def test_iterator(self):
+        with pd.read_csv(StringIO(self.data1), chunksize=1) as reader:
+            result = pd.concat(reader, ignore_index=True)
+        expected = pd.read_csv(StringIO(self.data1))
+        tm.assert_frame_equal(result, expected)
+
+        # GH12153
+        with pd.read_csv(StringIO(self.data1), chunksize=1) as it:
+            first = next(it)
+            tm.assert_frame_equal(first, expected.iloc[[0]])
+            tm.assert_frame_equal(pd.concat(it), expected.iloc[1:])
+
+    @pytest.mark.parametrize(
+        "reader, module, error_class, fn_ext",
+        [
+            (pd.read_csv, "os", FileNotFoundError, "csv"),
+            (pd.read_fwf, "os", FileNotFoundError, "txt"),
+            (pd.read_excel, "xlrd", FileNotFoundError, "xlsx"),
+            (pd.read_feather, "pyarrow", OSError, "feather"),
+            (pd.read_hdf, "tables", FileNotFoundError, "h5"),
+            (pd.read_stata, "os", FileNotFoundError, "dta"),
+            (pd.read_sas, "os", FileNotFoundError, "sas7bdat"),
+            (pd.read_json, "os", FileNotFoundError, "json"),
+            (pd.read_pickle, "os", FileNotFoundError, "pickle"),
+        ],
+    )
+    def test_read_non_existent(self, reader, module, error_class, fn_ext):
+        pytest.importorskip(module)
+
+        path = os.path.join(HERE, "data", "does_not_exist." + fn_ext)
+        msg1 = rf"File (b')?.+does_not_exist\.{fn_ext}'? does not exist"
+        msg2 = rf"\[Errno 2\] No such file or directory: '.+does_not_exist\.{fn_ext}'"
+        msg3 = "Expected object or value"
+        msg4 = "path_or_buf needs to be a string file path or file-like"
+        msg5 = (
+            rf"\[Errno 2\] File .+does_not_exist\.{fn_ext} does not exist: "
+            rf"'.+does_not_exist\.{fn_ext}'"
+        )
+        msg6 = rf"\[Errno 2\] 没有那个文件或目录: '.+does_not_exist\.{fn_ext}'"
+        msg7 = (
+            rf"\[Errno 2\] File o directory non esistente: '.+does_not_exist\.{fn_ext}'"
+        )
+        msg8 = rf"Failed to open local file.+does_not_exist\.{fn_ext}"
+
+        with pytest.raises(
+            error_class,
+            match=rf"({msg1}|{msg2}|{msg3}|{msg4}|{msg5}|{msg6}|{msg7}|{msg8})",
+        ):
+            reader(path)
+
+    @pytest.mark.parametrize(
+        "method, module, error_class, fn_ext",
+        [
+            (pd.DataFrame.to_csv, "os", OSError, "csv"),
+            (pd.DataFrame.to_html, "os", OSError, "html"),
+            (pd.DataFrame.to_excel, "xlrd", OSError, "xlsx"),
+            (pd.DataFrame.to_feather, "pyarrow", OSError, "feather"),
+            (pd.DataFrame.to_parquet, "pyarrow", OSError, "parquet"),
+            (pd.DataFrame.to_stata, "os", OSError, "dta"),
+            (pd.DataFrame.to_json, "os", OSError, "json"),
+            (pd.DataFrame.to_pickle, "os", OSError, "pickle"),
+        ],
+    )
+    # NOTE: Missing parent directory for pd.DataFrame.to_hdf is handled by PyTables
+    def test_write_missing_parent_directory(self, method, module, error_class, fn_ext):
+        pytest.importorskip(module)
+
+        dummy_frame = pd.DataFrame({"a": [1, 2, 3], "b": [2, 3, 4], "c": [3, 4, 5]})
+
+        path = os.path.join(HERE, "data", "missing_folder", "does_not_exist." + fn_ext)
+
+        with pytest.raises(
+            error_class,
+            match=r"Cannot save file into a non-existent directory: .*missing_folder",
+        ):
+            method(dummy_frame, path)
+
+    @pytest.mark.parametrize(
+        "reader, module, error_class, fn_ext",
+        [
+            (pd.read_csv, "os", FileNotFoundError, "csv"),
+            (pd.read_table, "os", FileNotFoundError, "csv"),
+            (pd.read_fwf, "os", FileNotFoundError, "txt"),
+            (pd.read_excel, "xlrd", FileNotFoundError, "xlsx"),
+            (pd.read_feather, "pyarrow", OSError, "feather"),
+            (pd.read_hdf, "tables", FileNotFoundError, "h5"),
+            (pd.read_stata, "os", FileNotFoundError, "dta"),
+            (pd.read_sas, "os", FileNotFoundError, "sas7bdat"),
+            (pd.read_json, "os", FileNotFoundError, "json"),
+            (pd.read_pickle, "os", FileNotFoundError, "pickle"),
+        ],
+    )
+    def test_read_expands_user_home_dir(
+        self, reader, module, error_class, fn_ext, monkeypatch
+    ):
+        pytest.importorskip(module)
+
+        path = os.path.join("~", "does_not_exist." + fn_ext)
+        monkeypatch.setattr(icom, "_expand_user", lambda x: os.path.join("foo", x))
+
+        msg1 = rf"File (b')?.+does_not_exist\.{fn_ext}'? does not exist"
+        msg2 = rf"\[Errno 2\] No such file or directory: '.+does_not_exist\.{fn_ext}'"
+        msg3 = "Unexpected character found when decoding 'false'"
+        msg4 = "path_or_buf needs to be a string file path or file-like"
+        msg5 = (
+            rf"\[Errno 2\] File .+does_not_exist\.{fn_ext} does not exist: "
+            rf"'.+does_not_exist\.{fn_ext}'"
+        )
+        msg6 = rf"\[Errno 2\] 没有那个文件或目录: '.+does_not_exist\.{fn_ext}'"
+        msg7 = (
+            rf"\[Errno 2\] File o directory non esistente: '.+does_not_exist\.{fn_ext}'"
+        )
+        msg8 = rf"Failed to open local file.+does_not_exist\.{fn_ext}"
+
+        with pytest.raises(
+            error_class,
+            match=rf"({msg1}|{msg2}|{msg3}|{msg4}|{msg5}|{msg6}|{msg7}|{msg8})",
+        ):
+            reader(path)
+
+    @pytest.mark.parametrize(
+        "reader, module, path",
+        [
+            (pd.read_csv, "os", ("io", "data", "csv", "iris.csv")),
+            (pd.read_table, "os", ("io", "data", "csv", "iris.csv")),
+            (
+                pd.read_fwf,
+                "os",
+                ("io", "data", "fixed_width", "fixed_width_format.txt"),
+            ),
+            (pd.read_excel, "xlrd", ("io", "data", "excel", "test1.xlsx")),
+            (
+                pd.read_feather,
+                "pyarrow",
+                ("io", "data", "feather", "feather-0_3_1.feather"),
+            ),
+            (
+                pd.read_hdf,
+                "tables",
+                ("io", "data", "legacy_hdf", "datetimetz_object.h5"),
+            ),
+            (pd.read_stata, "os", ("io", "data", "stata", "stata10_115.dta")),
+            (pd.read_sas, "os", ("io", "sas", "data", "test1.sas7bdat")),
+            (pd.read_json, "os", ("io", "json", "data", "tsframe_v012.json")),
+            (
+                pd.read_pickle,
+                "os",
+                ("io", "data", "pickle", "categorical.0.25.0.pickle"),
+            ),
+        ],
+    )
+    def test_read_fspath_all(self, reader, module, path, datapath):
+        pytest.importorskip(module)
+        path = datapath(*path)
+
+        mypath = CustomFSPath(path)
+        result = reader(mypath)
+        expected = reader(path)
+
+        if path.endswith(".pickle"):
+            # categorical
+            tm.assert_categorical_equal(result, expected)
+        else:
+            tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "writer_name, writer_kwargs, module",
+        [
+            ("to_csv", {}, "os"),
+            ("to_excel", {"engine": "openpyxl"}, "openpyxl"),
+            ("to_feather", {}, "pyarrow"),
+            ("to_html", {}, "os"),
+            ("to_json", {}, "os"),
+            ("to_latex", {}, "os"),
+            ("to_pickle", {}, "os"),
+            ("to_stata", {"time_stamp": pd.to_datetime("2019-01-01 00:00")}, "os"),
+        ],
+    )
+    def test_write_fspath_all(self, writer_name, writer_kwargs, module):
+        if writer_name in ["to_latex"]:  # uses Styler implementation
+            pytest.importorskip("jinja2")
+        p1 = tm.ensure_clean("string")
+        p2 = tm.ensure_clean("fspath")
+        df = pd.DataFrame({"A": [1, 2]})
+
+        with p1 as string, p2 as fspath:
+            pytest.importorskip(module)
+            mypath = CustomFSPath(fspath)
+            writer = getattr(df, writer_name)
+
+            writer(string, **writer_kwargs)
+            writer(mypath, **writer_kwargs)
+            with open(string, "rb") as f_str, open(fspath, "rb") as f_path:
+                if writer_name == "to_excel":
+                    # binary representation of excel contains time creation
+                    # data that causes flaky CI failures
+                    result = pd.read_excel(f_str, **writer_kwargs)
+                    expected = pd.read_excel(f_path, **writer_kwargs)
+                    tm.assert_frame_equal(result, expected)
+                else:
+                    result = f_str.read()
+                    expected = f_path.read()
+                    assert result == expected
+
+    def test_write_fspath_hdf5(self):
+        # Same test as write_fspath_all, except HDF5 files aren't
+        # necessarily byte-for-byte identical for a given dataframe, so we'll
+        # have to read and compare equality
+        pytest.importorskip("tables")
+
+        df = pd.DataFrame({"A": [1, 2]})
+        p1 = tm.ensure_clean("string")
+        p2 = tm.ensure_clean("fspath")
+
+        with p1 as string, p2 as fspath:
+            mypath = CustomFSPath(fspath)
+            df.to_hdf(mypath, key="bar")
+            df.to_hdf(string, key="bar")
+
+            result = pd.read_hdf(fspath, key="bar")
+            expected = pd.read_hdf(string, key="bar")
+
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.fixture
+def mmap_file(datapath):
+    return datapath("io", "data", "csv", "test_mmap.csv")
+
+
+class TestMMapWrapper:
+    def test_constructor_bad_file(self, mmap_file):
+        non_file = StringIO("I am not a file")
+        non_file.fileno = lambda: -1
+
+        # the error raised is different on Windows
+        if is_platform_windows():
+            msg = "The parameter is incorrect"
+            err = OSError
+        else:
+            msg = "[Errno 22]"
+            err = mmap.error
+
+        with pytest.raises(err, match=msg):
+            icom._maybe_memory_map(non_file, True)
+
+        with open(mmap_file, encoding="utf-8") as target:
+            pass
+
+        msg = "I/O operation on closed file"
+        with pytest.raises(ValueError, match=msg):
+            icom._maybe_memory_map(target, True)
+
+    def test_next(self, mmap_file):
+        with open(mmap_file, encoding="utf-8") as target:
+            lines = target.readlines()
+
+            with icom.get_handle(
+                target, "r", is_text=True, memory_map=True
+            ) as wrappers:
+                wrapper = wrappers.handle
+                assert isinstance(wrapper.buffer.buffer, mmap.mmap)
+
+                for line in lines:
+                    next_line = next(wrapper)
+                    assert next_line.strip() == line.strip()
+
+                with pytest.raises(StopIteration, match=r"^$"):
+                    next(wrapper)
+
+    def test_unknown_engine(self):
+        with tm.ensure_clean() as path:
+            df = pd.DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=pd.Index(list("ABCD"), dtype=object),
+                index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
+            df.to_csv(path)
+            with pytest.raises(ValueError, match="Unknown engine"):
+                pd.read_csv(path, engine="pyt")
+
+    def test_binary_mode(self):
+        """
+        'encoding' shouldn't be passed to 'open' in binary mode.
+
+        GH 35058
+        """
+        with tm.ensure_clean() as path:
+            df = pd.DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=pd.Index(list("ABCD"), dtype=object),
+                index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
+            df.to_csv(path, mode="w+b")
+            tm.assert_frame_equal(df, pd.read_csv(path, index_col=0))
+
+    @pytest.mark.parametrize("encoding", ["utf-16", "utf-32"])
+    @pytest.mark.parametrize("compression_", ["bz2", "xz"])
+    def test_warning_missing_utf_bom(self, encoding, compression_):
+        """
+        bz2 and xz do not write the byte order mark (BOM) for utf-16/32.
+
+        https://stackoverflow.com/questions/55171439
+
+        GH 35681
+        """
+        df = pd.DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        with tm.ensure_clean() as path:
+            with tm.assert_produces_warning(UnicodeWarning):
+                df.to_csv(path, compression=compression_, encoding=encoding)
+
+            # reading should fail (otherwise we wouldn't need the warning)
+            msg = r"UTF-\d+ stream does not start with BOM"
+            with pytest.raises(UnicodeError, match=msg):
+                pd.read_csv(path, compression=compression_, encoding=encoding)
+
+
+def test_is_fsspec_url():
+    assert icom.is_fsspec_url("gcs://pandas/somethingelse.com")
+    assert icom.is_fsspec_url("gs://pandas/somethingelse.com")
+    # the following is the only remote URL that is handled without fsspec
+    assert not icom.is_fsspec_url("http://pandas/somethingelse.com")
+    assert not icom.is_fsspec_url("random:pandas/somethingelse.com")
+    assert not icom.is_fsspec_url("/local/path")
+    assert not icom.is_fsspec_url("relative/local/path")
+    # fsspec URL in string should not be recognized
+    assert not icom.is_fsspec_url("this is not fsspec://url")
+    assert not icom.is_fsspec_url("{'url': 'gs://pandas/somethingelse.com'}")
+    # accept everything that conforms to RFC 3986 schema
+    assert icom.is_fsspec_url("RFC-3986+compliant.spec://something")
+
+
+@pytest.mark.parametrize("encoding", [None, "utf-8"])
+@pytest.mark.parametrize("format", ["csv", "json"])
+def test_codecs_encoding(encoding, format):
+    # GH39247
+    expected = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+    with tm.ensure_clean() as path:
+        with codecs.open(path, mode="w", encoding=encoding) as handle:
+            getattr(expected, f"to_{format}")(handle)
+        with codecs.open(path, mode="r", encoding=encoding) as handle:
+            if format == "csv":
+                df = pd.read_csv(handle, index_col=0)
+            else:
+                df = pd.read_json(handle)
+    tm.assert_frame_equal(expected, df)
+
+
+def test_codecs_get_writer_reader():
+    # GH39247
+    expected = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+    with tm.ensure_clean() as path:
+        with open(path, "wb") as handle:
+            with codecs.getwriter("utf-8")(handle) as encoded:
+                expected.to_csv(encoded)
+        with open(path, "rb") as handle:
+            with codecs.getreader("utf-8")(handle) as encoded:
+                df = pd.read_csv(encoded, index_col=0)
+    tm.assert_frame_equal(expected, df)
+
+
+@pytest.mark.parametrize(
+    "io_class,mode,msg",
+    [
+        (BytesIO, "t", "a bytes-like object is required, not 'str'"),
+        (StringIO, "b", "string argument expected, got 'bytes'"),
+    ],
+)
+def test_explicit_encoding(io_class, mode, msg):
+    # GH39247; this test makes sure that if a user provides mode="*t" or "*b",
+    # it is used. In the case of this test it leads to an error as intentionally the
+    # wrong mode is requested
+    expected = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+    with io_class() as buffer:
+        with pytest.raises(TypeError, match=msg):
+            expected.to_csv(buffer, mode=f"w{mode}")
+
+
+@pytest.mark.parametrize("encoding_errors", [None, "strict", "replace"])
+@pytest.mark.parametrize("format", ["csv", "json"])
+def test_encoding_errors(encoding_errors, format):
+    # GH39450
+    msg = "'utf-8' codec can't decode byte"
+    bad_encoding = b"\xe4"
+
+    if format == "csv":
+        content = b"," + bad_encoding + b"\n" + bad_encoding * 2 + b"," + bad_encoding
+        reader = partial(pd.read_csv, index_col=0)
+    else:
+        content = (
+            b'{"'
+            + bad_encoding * 2
+            + b'": {"'
+            + bad_encoding
+            + b'":"'
+            + bad_encoding
+            + b'"}}'
+        )
+        reader = partial(pd.read_json, orient="index")
+    with tm.ensure_clean() as path:
+        file = Path(path)
+        file.write_bytes(content)
+
+        if encoding_errors != "replace":
+            with pytest.raises(UnicodeDecodeError, match=msg):
+                reader(path, encoding_errors=encoding_errors)
+        else:
+            df = reader(path, encoding_errors=encoding_errors)
+            decoded = bad_encoding.decode(errors=encoding_errors)
+            expected = pd.DataFrame({decoded: [decoded]}, index=[decoded * 2])
+            tm.assert_frame_equal(df, expected)
+
+
+def test_bad_encdoing_errors():
+    # GH 39777
+    with tm.ensure_clean() as path:
+        with pytest.raises(LookupError, match="unknown error handler name"):
+            icom.get_handle(path, "w", errors="bad")
+
+
+def test_errno_attribute():
+    # GH 13872
+    with pytest.raises(FileNotFoundError, match="\\[Errno 2\\]") as err:
+        pd.read_csv("doesnt_exist")
+        assert err.errno == errno.ENOENT
+
+
+def test_fail_mmap():
+    with pytest.raises(UnsupportedOperation, match="fileno"):
+        with BytesIO() as buffer:
+            icom.get_handle(buffer, "rb", memory_map=True)
+
+
+def test_close_on_error():
+    # GH 47136
+    class TestError:
+        def close(self):
+            raise OSError("test")
+
+    with pytest.raises(OSError, match="test"):
+        with BytesIO() as buffer:
+            with icom.get_handle(buffer, "rb") as handles:
+                handles.created_handles.append(TestError())
+
+
+@pytest.mark.parametrize(
+    "reader",
+    [
+        pd.read_csv,
+        pd.read_fwf,
+        pd.read_excel,
+        pd.read_feather,
+        pd.read_hdf,
+        pd.read_stata,
+        pd.read_sas,
+        pd.read_json,
+        pd.read_pickle,
+    ],
+)
+def test_pickle_reader(reader):
+    # GH 22265
+    with BytesIO() as buffer:
+        pickle.dump(reader, buffer)

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

@@ -0,0 +1,378 @@
+import gzip
+import io
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tarfile
+import textwrap
+import time
+import zipfile
+
+import numpy as np
+import pytest
+
+from pandas.compat import is_platform_windows
+
+import pandas as pd
+import pandas._testing as tm
+
+import pandas.io.common as icom
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        pd.DataFrame(
+            100 * [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+            columns=["X", "Y", "Z"],
+        ),
+        pd.Series(100 * [0.123456, 0.234567, 0.567567], name="X"),
+    ],
+)
+@pytest.mark.parametrize("method", ["to_pickle", "to_json", "to_csv"])
+def test_compression_size(obj, method, compression_only):
+    if compression_only == "tar":
+        compression_only = {"method": "tar", "mode": "w:gz"}
+
+    with tm.ensure_clean() as path:
+        getattr(obj, method)(path, compression=compression_only)
+        compressed_size = os.path.getsize(path)
+        getattr(obj, method)(path, compression=None)
+        uncompressed_size = os.path.getsize(path)
+        assert uncompressed_size > compressed_size
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        pd.DataFrame(
+            100 * [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+            columns=["X", "Y", "Z"],
+        ),
+        pd.Series(100 * [0.123456, 0.234567, 0.567567], name="X"),
+    ],
+)
+@pytest.mark.parametrize("method", ["to_csv", "to_json"])
+def test_compression_size_fh(obj, method, compression_only):
+    with tm.ensure_clean() as path:
+        with icom.get_handle(
+            path,
+            "w:gz" if compression_only == "tar" else "w",
+            compression=compression_only,
+        ) as handles:
+            getattr(obj, method)(handles.handle)
+            assert not handles.handle.closed
+        compressed_size = os.path.getsize(path)
+    with tm.ensure_clean() as path:
+        with icom.get_handle(path, "w", compression=None) as handles:
+            getattr(obj, method)(handles.handle)
+            assert not handles.handle.closed
+        uncompressed_size = os.path.getsize(path)
+        assert uncompressed_size > compressed_size
+
+
+@pytest.mark.parametrize(
+    "write_method, write_kwargs, read_method",
+    [
+        ("to_csv", {"index": False}, pd.read_csv),
+        ("to_json", {}, pd.read_json),
+        ("to_pickle", {}, pd.read_pickle),
+    ],
+)
+def test_dataframe_compression_defaults_to_infer(
+    write_method, write_kwargs, read_method, compression_only, compression_to_extension
+):
+    # GH22004
+    input = pd.DataFrame([[1.0, 0, -4], [3.4, 5, 2]], columns=["X", "Y", "Z"])
+    extension = compression_to_extension[compression_only]
+    with tm.ensure_clean("compressed" + extension) as path:
+        getattr(input, write_method)(path, **write_kwargs)
+        output = read_method(path, compression=compression_only)
+    tm.assert_frame_equal(output, input)
+
+
+@pytest.mark.parametrize(
+    "write_method,write_kwargs,read_method,read_kwargs",
+    [
+        ("to_csv", {"index": False, "header": True}, pd.read_csv, {"squeeze": True}),
+        ("to_json", {}, pd.read_json, {"typ": "series"}),
+        ("to_pickle", {}, pd.read_pickle, {}),
+    ],
+)
+def test_series_compression_defaults_to_infer(
+    write_method,
+    write_kwargs,
+    read_method,
+    read_kwargs,
+    compression_only,
+    compression_to_extension,
+):
+    # GH22004
+    input = pd.Series([0, 5, -2, 10], name="X")
+    extension = compression_to_extension[compression_only]
+    with tm.ensure_clean("compressed" + extension) as path:
+        getattr(input, write_method)(path, **write_kwargs)
+        if "squeeze" in read_kwargs:
+            kwargs = read_kwargs.copy()
+            del kwargs["squeeze"]
+            output = read_method(path, compression=compression_only, **kwargs).squeeze(
+                "columns"
+            )
+        else:
+            output = read_method(path, compression=compression_only, **read_kwargs)
+    tm.assert_series_equal(output, input, check_names=False)
+
+
+def test_compression_warning(compression_only):
+    # Assert that passing a file object to to_csv while explicitly specifying a
+    # compression protocol triggers a RuntimeWarning, as per GH21227.
+    df = pd.DataFrame(
+        100 * [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+        columns=["X", "Y", "Z"],
+    )
+    with tm.ensure_clean() as path:
+        with icom.get_handle(path, "w", compression=compression_only) as handles:
+            with tm.assert_produces_warning(RuntimeWarning):
+                df.to_csv(handles.handle, compression=compression_only)
+
+
+def test_compression_binary(compression_only):
+    """
+    Binary file handles support compression.
+
+    GH22555
+    """
+    df = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+
+    # with a file
+    with tm.ensure_clean() as path:
+        with open(path, mode="wb") as file:
+            df.to_csv(file, mode="wb", compression=compression_only)
+            file.seek(0)  # file shouldn't be closed
+        tm.assert_frame_equal(
+            df, pd.read_csv(path, index_col=0, compression=compression_only)
+        )
+
+    # with BytesIO
+    file = io.BytesIO()
+    df.to_csv(file, mode="wb", compression=compression_only)
+    file.seek(0)  # file shouldn't be closed
+    tm.assert_frame_equal(
+        df, pd.read_csv(file, index_col=0, compression=compression_only)
+    )
+
+
+def test_gzip_reproducibility_file_name():
+    """
+    Gzip should create reproducible archives with mtime.
+
+    Note: Archives created with different filenames will still be different!
+
+    GH 28103
+    """
+    df = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+    compression_options = {"method": "gzip", "mtime": 1}
+
+    # test for filename
+    with tm.ensure_clean() as path:
+        path = Path(path)
+        df.to_csv(path, compression=compression_options)
+        time.sleep(0.1)
+        output = path.read_bytes()
+        df.to_csv(path, compression=compression_options)
+        assert output == path.read_bytes()
+
+
+def test_gzip_reproducibility_file_object():
+    """
+    Gzip should create reproducible archives with mtime.
+
+    GH 28103
+    """
+    df = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+    compression_options = {"method": "gzip", "mtime": 1}
+
+    # test for file object
+    buffer = io.BytesIO()
+    df.to_csv(buffer, compression=compression_options, mode="wb")
+    output = buffer.getvalue()
+    time.sleep(0.1)
+    buffer = io.BytesIO()
+    df.to_csv(buffer, compression=compression_options, mode="wb")
+    assert output == buffer.getvalue()
+
+
+@pytest.mark.single_cpu
+def test_with_missing_lzma():
+    """Tests if import pandas works when lzma is not present."""
+    # https://github.com/pandas-dev/pandas/issues/27575
+    code = textwrap.dedent(
+        """\
+        import sys
+        sys.modules['lzma'] = None
+        import pandas
+        """
+    )
+    subprocess.check_output([sys.executable, "-c", code], stderr=subprocess.PIPE)
+
+
+@pytest.mark.single_cpu
+def test_with_missing_lzma_runtime():
+    """Tests if RuntimeError is hit when calling lzma without
+    having the module available.
+    """
+    code = textwrap.dedent(
+        """
+        import sys
+        import pytest
+        sys.modules['lzma'] = None
+        import pandas as pd
+        df = pd.DataFrame()
+        with pytest.raises(RuntimeError, match='lzma module'):
+            df.to_csv('foo.csv', compression='xz')
+        """
+    )
+    subprocess.check_output([sys.executable, "-c", code], stderr=subprocess.PIPE)
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        pd.DataFrame(
+            100 * [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+            columns=["X", "Y", "Z"],
+        ),
+        pd.Series(100 * [0.123456, 0.234567, 0.567567], name="X"),
+    ],
+)
+@pytest.mark.parametrize("method", ["to_pickle", "to_json", "to_csv"])
+def test_gzip_compression_level(obj, method):
+    # GH33196
+    with tm.ensure_clean() as path:
+        getattr(obj, method)(path, compression="gzip")
+        compressed_size_default = os.path.getsize(path)
+        getattr(obj, method)(path, compression={"method": "gzip", "compresslevel": 1})
+        compressed_size_fast = os.path.getsize(path)
+        assert compressed_size_default < compressed_size_fast
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        pd.DataFrame(
+            100 * [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+            columns=["X", "Y", "Z"],
+        ),
+        pd.Series(100 * [0.123456, 0.234567, 0.567567], name="X"),
+    ],
+)
+@pytest.mark.parametrize("method", ["to_pickle", "to_json", "to_csv"])
+def test_xz_compression_level_read(obj, method):
+    with tm.ensure_clean() as path:
+        getattr(obj, method)(path, compression="xz")
+        compressed_size_default = os.path.getsize(path)
+        getattr(obj, method)(path, compression={"method": "xz", "preset": 1})
+        compressed_size_fast = os.path.getsize(path)
+        assert compressed_size_default < compressed_size_fast
+        if method == "to_csv":
+            pd.read_csv(path, compression="xz")
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        pd.DataFrame(
+            100 * [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+            columns=["X", "Y", "Z"],
+        ),
+        pd.Series(100 * [0.123456, 0.234567, 0.567567], name="X"),
+    ],
+)
+@pytest.mark.parametrize("method", ["to_pickle", "to_json", "to_csv"])
+def test_bzip_compression_level(obj, method):
+    """GH33196 bzip needs file size > 100k to show a size difference between
+    compression levels, so here we just check if the call works when
+    compression is passed as a dict.
+    """
+    with tm.ensure_clean() as path:
+        getattr(obj, method)(path, compression={"method": "bz2", "compresslevel": 1})
+
+
+@pytest.mark.parametrize(
+    "suffix,archive",
+    [
+        (".zip", zipfile.ZipFile),
+        (".tar", tarfile.TarFile),
+    ],
+)
+def test_empty_archive_zip(suffix, archive):
+    with tm.ensure_clean(filename=suffix) as path:
+        with archive(path, "w"):
+            pass
+        with pytest.raises(ValueError, match="Zero files found"):
+            pd.read_csv(path)
+
+
+def test_ambiguous_archive_zip():
+    with tm.ensure_clean(filename=".zip") as path:
+        with zipfile.ZipFile(path, "w") as file:
+            file.writestr("a.csv", "foo,bar")
+            file.writestr("b.csv", "foo,bar")
+        with pytest.raises(ValueError, match="Multiple files found in ZIP file"):
+            pd.read_csv(path)
+
+
+def test_ambiguous_archive_tar(tmp_path):
+    csvAPath = tmp_path / "a.csv"
+    with open(csvAPath, "w", encoding="utf-8") as a:
+        a.write("foo,bar\n")
+    csvBPath = tmp_path / "b.csv"
+    with open(csvBPath, "w", encoding="utf-8") as b:
+        b.write("foo,bar\n")
+
+    tarpath = tmp_path / "archive.tar"
+    with tarfile.TarFile(tarpath, "w") as tar:
+        tar.add(csvAPath, "a.csv")
+        tar.add(csvBPath, "b.csv")
+
+    with pytest.raises(ValueError, match="Multiple files found in TAR archive"):
+        pd.read_csv(tarpath)
+
+
+def test_tar_gz_to_different_filename():
+    with tm.ensure_clean(filename=".foo") as file:
+        pd.DataFrame(
+            [["1", "2"]],
+            columns=["foo", "bar"],
+        ).to_csv(file, compression={"method": "tar", "mode": "w:gz"}, index=False)
+        with gzip.open(file) as uncompressed:
+            with tarfile.TarFile(fileobj=uncompressed) as archive:
+                members = archive.getmembers()
+                assert len(members) == 1
+                content = archive.extractfile(members[0]).read().decode("utf8")
+
+                if is_platform_windows():
+                    expected = "foo,bar\r\n1,2\r\n"
+                else:
+                    expected = "foo,bar\n1,2\n"
+
+                assert content == expected
+
+
+def test_tar_no_error_on_close():
+    with io.BytesIO() as buffer:
+        with icom._BytesTarFile(fileobj=buffer, mode="w"):
+            pass

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

@@ -0,0 +1,252 @@
+""" test feather-format compat """
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import (
+    ArrowStringArray,
+    StringArray,
+)
+
+from pandas.io.feather_format import read_feather, to_feather  # isort:skip
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+pa = pytest.importorskip("pyarrow")
+
+
+@pytest.mark.single_cpu
+class TestFeather:
+    def check_error_on_write(self, df, exc, err_msg):
+        # check that we are raising the exception
+        # on writing
+
+        with pytest.raises(exc, match=err_msg):
+            with tm.ensure_clean() as path:
+                to_feather(df, path)
+
+    def check_external_error_on_write(self, df):
+        # check that we are raising the exception
+        # on writing
+
+        with tm.external_error_raised(Exception):
+            with tm.ensure_clean() as path:
+                to_feather(df, path)
+
+    def check_round_trip(self, df, expected=None, write_kwargs={}, **read_kwargs):
+        if expected is None:
+            expected = df.copy()
+
+        with tm.ensure_clean() as path:
+            to_feather(df, path, **write_kwargs)
+
+            result = read_feather(path, **read_kwargs)
+
+            tm.assert_frame_equal(result, expected)
+
+    def test_error(self):
+        msg = "feather only support IO with DataFrames"
+        for obj in [
+            pd.Series([1, 2, 3]),
+            1,
+            "foo",
+            pd.Timestamp("20130101"),
+            np.array([1, 2, 3]),
+        ]:
+            self.check_error_on_write(obj, ValueError, msg)
+
+    def test_basic(self):
+        df = pd.DataFrame(
+            {
+                "string": list("abc"),
+                "int": list(range(1, 4)),
+                "uint": np.arange(3, 6).astype("u1"),
+                "float": np.arange(4.0, 7.0, dtype="float64"),
+                "float_with_null": [1.0, np.nan, 3],
+                "bool": [True, False, True],
+                "bool_with_null": [True, np.nan, False],
+                "cat": pd.Categorical(list("abc")),
+                "dt": pd.DatetimeIndex(
+                    list(pd.date_range("20130101", periods=3)), freq=None
+                ),
+                "dttz": pd.DatetimeIndex(
+                    list(pd.date_range("20130101", periods=3, tz="US/Eastern")),
+                    freq=None,
+                ),
+                "dt_with_null": [
+                    pd.Timestamp("20130101"),
+                    pd.NaT,
+                    pd.Timestamp("20130103"),
+                ],
+                "dtns": pd.DatetimeIndex(
+                    list(pd.date_range("20130101", periods=3, freq="ns")), freq=None
+                ),
+            }
+        )
+        df["periods"] = pd.period_range("2013", freq="M", periods=3)
+        df["timedeltas"] = pd.timedelta_range("1 day", periods=3)
+        df["intervals"] = pd.interval_range(0, 3, 3)
+
+        assert df.dttz.dtype.tz.zone == "US/Eastern"
+
+        expected = df.copy()
+        expected.loc[1, "bool_with_null"] = None
+        self.check_round_trip(df, expected=expected)
+
+    def test_duplicate_columns(self):
+        # https://github.com/wesm/feather/issues/53
+        # not currently able to handle duplicate columns
+        df = pd.DataFrame(np.arange(12).reshape(4, 3), columns=list("aaa")).copy()
+        self.check_external_error_on_write(df)
+
+    def test_read_columns(self):
+        # GH 24025
+        df = pd.DataFrame(
+            {
+                "col1": list("abc"),
+                "col2": list(range(1, 4)),
+                "col3": list("xyz"),
+                "col4": list(range(4, 7)),
+            }
+        )
+        columns = ["col1", "col3"]
+        self.check_round_trip(df, expected=df[columns], columns=columns)
+
+    def test_read_columns_different_order(self):
+        # GH 33878
+        df = pd.DataFrame({"A": [1, 2], "B": ["x", "y"], "C": [True, False]})
+        expected = df[["B", "A"]]
+        self.check_round_trip(df, expected, columns=["B", "A"])
+
+    def test_unsupported_other(self):
+        # mixed python objects
+        df = pd.DataFrame({"a": ["a", 1, 2.0]})
+        self.check_external_error_on_write(df)
+
+    def test_rw_use_threads(self):
+        df = pd.DataFrame({"A": np.arange(100000)})
+        self.check_round_trip(df, use_threads=True)
+        self.check_round_trip(df, use_threads=False)
+
+    def test_path_pathlib(self):
+        df = pd.DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        ).reset_index()
+        result = tm.round_trip_pathlib(df.to_feather, read_feather)
+        tm.assert_frame_equal(df, result)
+
+    def test_path_localpath(self):
+        df = pd.DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        ).reset_index()
+        result = tm.round_trip_localpath(df.to_feather, read_feather)
+        tm.assert_frame_equal(df, result)
+
+    def test_passthrough_keywords(self):
+        df = pd.DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        ).reset_index()
+        self.check_round_trip(df, write_kwargs={"version": 1})
+
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    def test_http_path(self, feather_file, httpserver):
+        # GH 29055
+        expected = read_feather(feather_file)
+        with open(feather_file, "rb") as f:
+            httpserver.serve_content(content=f.read())
+            res = read_feather(httpserver.url)
+        tm.assert_frame_equal(expected, res)
+
+    def test_read_feather_dtype_backend(self, string_storage, dtype_backend):
+        # GH#50765
+        df = pd.DataFrame(
+            {
+                "a": pd.Series([1, np.nan, 3], dtype="Int64"),
+                "b": pd.Series([1, 2, 3], dtype="Int64"),
+                "c": pd.Series([1.5, np.nan, 2.5], dtype="Float64"),
+                "d": pd.Series([1.5, 2.0, 2.5], dtype="Float64"),
+                "e": [True, False, None],
+                "f": [True, False, True],
+                "g": ["a", "b", "c"],
+                "h": ["a", "b", None],
+            }
+        )
+
+        if string_storage == "python":
+            string_array = StringArray(np.array(["a", "b", "c"], dtype=np.object_))
+            string_array_na = StringArray(np.array(["a", "b", pd.NA], dtype=np.object_))
+
+        elif dtype_backend == "pyarrow":
+            from pandas.arrays import ArrowExtensionArray
+
+            string_array = ArrowExtensionArray(pa.array(["a", "b", "c"]))
+            string_array_na = ArrowExtensionArray(pa.array(["a", "b", None]))
+
+        else:
+            string_array = ArrowStringArray(pa.array(["a", "b", "c"]))
+            string_array_na = ArrowStringArray(pa.array(["a", "b", None]))
+
+        with tm.ensure_clean() as path:
+            to_feather(df, path)
+            with pd.option_context("mode.string_storage", string_storage):
+                result = read_feather(path, dtype_backend=dtype_backend)
+
+        expected = pd.DataFrame(
+            {
+                "a": pd.Series([1, np.nan, 3], dtype="Int64"),
+                "b": pd.Series([1, 2, 3], dtype="Int64"),
+                "c": pd.Series([1.5, np.nan, 2.5], dtype="Float64"),
+                "d": pd.Series([1.5, 2.0, 2.5], dtype="Float64"),
+                "e": pd.Series([True, False, pd.NA], dtype="boolean"),
+                "f": pd.Series([True, False, True], dtype="boolean"),
+                "g": string_array,
+                "h": string_array_na,
+            }
+        )
+
+        if dtype_backend == "pyarrow":
+            from pandas.arrays import ArrowExtensionArray
+
+            expected = pd.DataFrame(
+                {
+                    col: ArrowExtensionArray(pa.array(expected[col], from_pandas=True))
+                    for col in expected.columns
+                }
+            )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_int_columns_and_index(self):
+        df = pd.DataFrame({"a": [1, 2, 3]}, index=pd.Index([3, 4, 5], name="test"))
+        self.check_round_trip(df)
+
+    def test_invalid_dtype_backend(self):
+        msg = (
+            "dtype_backend numpy is invalid, only 'numpy_nullable' and "
+            "'pyarrow' are allowed."
+        )
+        df = pd.DataFrame({"int": list(range(1, 4))})
+        with tm.ensure_clean("tmp.feather") as path:
+            df.to_feather(path)
+            with pytest.raises(ValueError, match=msg):
+                read_feather(path, dtype_backend="numpy")
+
+    def test_string_inference(self, tmp_path):
+        # GH#54431
+        path = tmp_path / "test_string_inference.p"
+        df = pd.DataFrame(data={"a": ["x", "y"]})
+        df.to_feather(path)
+        with pd.option_context("future.infer_string", True):
+            result = read_feather(path)
+        expected = pd.DataFrame(data={"a": ["x", "y"]}, dtype="string[pyarrow_numpy]")
+        tm.assert_frame_equal(result, expected)

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

@@ -0,0 +1,345 @@
+import io
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    date_range,
+    read_csv,
+    read_excel,
+    read_feather,
+    read_json,
+    read_parquet,
+    read_pickle,
+    read_stata,
+    read_table,
+)
+import pandas._testing as tm
+from pandas.util import _test_decorators as td
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+@pytest.fixture
+def fsspectest():
+    pytest.importorskip("fsspec")
+    from fsspec import register_implementation
+    from fsspec.implementations.memory import MemoryFileSystem
+    from fsspec.registry import _registry as registry
+
+    class TestMemoryFS(MemoryFileSystem):
+        protocol = "testmem"
+        test = [None]
+
+        def __init__(self, **kwargs) -> None:
+            self.test[0] = kwargs.pop("test", None)
+            super().__init__(**kwargs)
+
+    register_implementation("testmem", TestMemoryFS, clobber=True)
+    yield TestMemoryFS()
+    registry.pop("testmem", None)
+    TestMemoryFS.test[0] = None
+    TestMemoryFS.store.clear()
+
+
+@pytest.fixture
+def df1():
+    return DataFrame(
+        {
+            "int": [1, 3],
+            "float": [2.0, np.nan],
+            "str": ["t", "s"],
+            "dt": date_range("2018-06-18", periods=2),
+        }
+    )
+
+
+@pytest.fixture
+def cleared_fs():
+    fsspec = pytest.importorskip("fsspec")
+
+    memfs = fsspec.filesystem("memory")
+    yield memfs
+    memfs.store.clear()
+
+
+def test_read_csv(cleared_fs, df1):
+    text = str(df1.to_csv(index=False)).encode()
+    with cleared_fs.open("test/test.csv", "wb") as w:
+        w.write(text)
+    df2 = read_csv("memory://test/test.csv", parse_dates=["dt"])
+
+    tm.assert_frame_equal(df1, df2)
+
+
+def test_reasonable_error(monkeypatch, cleared_fs):
+    from fsspec.registry import known_implementations
+
+    with pytest.raises(ValueError, match="nosuchprotocol"):
+        read_csv("nosuchprotocol://test/test.csv")
+    err_msg = "test error message"
+    monkeypatch.setitem(
+        known_implementations,
+        "couldexist",
+        {"class": "unimportable.CouldExist", "err": err_msg},
+    )
+    with pytest.raises(ImportError, match=err_msg):
+        read_csv("couldexist://test/test.csv")
+
+
+def test_to_csv(cleared_fs, df1):
+    df1.to_csv("memory://test/test.csv", index=True)
+
+    df2 = read_csv("memory://test/test.csv", parse_dates=["dt"], index_col=0)
+
+    tm.assert_frame_equal(df1, df2)
+
+
+def test_to_excel(cleared_fs, df1):
+    pytest.importorskip("openpyxl")
+    ext = "xlsx"
+    path = f"memory://test/test.{ext}"
+    df1.to_excel(path, index=True)
+
+    df2 = read_excel(path, parse_dates=["dt"], index_col=0)
+
+    tm.assert_frame_equal(df1, df2)
+
+
+@pytest.mark.parametrize("binary_mode", [False, True])
+def test_to_csv_fsspec_object(cleared_fs, binary_mode, df1):
+    fsspec = pytest.importorskip("fsspec")
+
+    path = "memory://test/test.csv"
+    mode = "wb" if binary_mode else "w"
+    with fsspec.open(path, mode=mode).open() as fsspec_object:
+        df1.to_csv(fsspec_object, index=True)
+        assert not fsspec_object.closed
+
+    mode = mode.replace("w", "r")
+    with fsspec.open(path, mode=mode) as fsspec_object:
+        df2 = read_csv(
+            fsspec_object,
+            parse_dates=["dt"],
+            index_col=0,
+        )
+        assert not fsspec_object.closed
+
+    tm.assert_frame_equal(df1, df2)
+
+
+def test_csv_options(fsspectest):
+    df = DataFrame({"a": [0]})
+    df.to_csv(
+        "testmem://test/test.csv", storage_options={"test": "csv_write"}, index=False
+    )
+    assert fsspectest.test[0] == "csv_write"
+    read_csv("testmem://test/test.csv", storage_options={"test": "csv_read"})
+    assert fsspectest.test[0] == "csv_read"
+
+
+def test_read_table_options(fsspectest):
+    # GH #39167
+    df = DataFrame({"a": [0]})
+    df.to_csv(
+        "testmem://test/test.csv", storage_options={"test": "csv_write"}, index=False
+    )
+    assert fsspectest.test[0] == "csv_write"
+    read_table("testmem://test/test.csv", storage_options={"test": "csv_read"})
+    assert fsspectest.test[0] == "csv_read"
+
+
+def test_excel_options(fsspectest):
+    pytest.importorskip("openpyxl")
+    extension = "xlsx"
+
+    df = DataFrame({"a": [0]})
+
+    path = f"testmem://test/test.{extension}"
+
+    df.to_excel(path, storage_options={"test": "write"}, index=False)
+    assert fsspectest.test[0] == "write"
+    read_excel(path, storage_options={"test": "read"})
+    assert fsspectest.test[0] == "read"
+
+
+def test_to_parquet_new_file(cleared_fs, df1):
+    """Regression test for writing to a not-yet-existent GCS Parquet file."""
+    pytest.importorskip("fastparquet")
+
+    df1.to_parquet(
+        "memory://test/test.csv", index=True, engine="fastparquet", compression=None
+    )
+
+
+def test_arrowparquet_options(fsspectest):
+    """Regression test for writing to a not-yet-existent GCS Parquet file."""
+    pytest.importorskip("pyarrow")
+    df = DataFrame({"a": [0]})
+    df.to_parquet(
+        "testmem://test/test.csv",
+        engine="pyarrow",
+        compression=None,
+        storage_options={"test": "parquet_write"},
+    )
+    assert fsspectest.test[0] == "parquet_write"
+    read_parquet(
+        "testmem://test/test.csv",
+        engine="pyarrow",
+        storage_options={"test": "parquet_read"},
+    )
+    assert fsspectest.test[0] == "parquet_read"
+
+
+@td.skip_array_manager_not_yet_implemented  # TODO(ArrayManager) fastparquet
+def test_fastparquet_options(fsspectest):
+    """Regression test for writing to a not-yet-existent GCS Parquet file."""
+    pytest.importorskip("fastparquet")
+
+    df = DataFrame({"a": [0]})
+    df.to_parquet(
+        "testmem://test/test.csv",
+        engine="fastparquet",
+        compression=None,
+        storage_options={"test": "parquet_write"},
+    )
+    assert fsspectest.test[0] == "parquet_write"
+    read_parquet(
+        "testmem://test/test.csv",
+        engine="fastparquet",
+        storage_options={"test": "parquet_read"},
+    )
+    assert fsspectest.test[0] == "parquet_read"
+
+
+@pytest.mark.single_cpu
+def test_from_s3_csv(s3_public_bucket_with_data, tips_file, s3so):
+    pytest.importorskip("s3fs")
+    tm.assert_equal(
+        read_csv(
+            f"s3://{s3_public_bucket_with_data.name}/tips.csv", storage_options=s3so
+        ),
+        read_csv(tips_file),
+    )
+    # the following are decompressed by pandas, not fsspec
+    tm.assert_equal(
+        read_csv(
+            f"s3://{s3_public_bucket_with_data.name}/tips.csv.gz", storage_options=s3so
+        ),
+        read_csv(tips_file),
+    )
+    tm.assert_equal(
+        read_csv(
+            f"s3://{s3_public_bucket_with_data.name}/tips.csv.bz2", storage_options=s3so
+        ),
+        read_csv(tips_file),
+    )
+
+
+@pytest.mark.single_cpu
+@pytest.mark.parametrize("protocol", ["s3", "s3a", "s3n"])
+def test_s3_protocols(s3_public_bucket_with_data, tips_file, protocol, s3so):
+    pytest.importorskip("s3fs")
+    tm.assert_equal(
+        read_csv(
+            f"{protocol}://{s3_public_bucket_with_data.name}/tips.csv",
+            storage_options=s3so,
+        ),
+        read_csv(tips_file),
+    )
+
+
+@pytest.mark.single_cpu
+@td.skip_array_manager_not_yet_implemented  # TODO(ArrayManager) fastparquet
+def test_s3_parquet(s3_public_bucket, s3so, df1):
+    pytest.importorskip("fastparquet")
+    pytest.importorskip("s3fs")
+
+    fn = f"s3://{s3_public_bucket.name}/test.parquet"
+    df1.to_parquet(
+        fn, index=False, engine="fastparquet", compression=None, storage_options=s3so
+    )
+    df2 = read_parquet(fn, engine="fastparquet", storage_options=s3so)
+    tm.assert_equal(df1, df2)
+
+
+@td.skip_if_installed("fsspec")
+def test_not_present_exception():
+    msg = "Missing optional dependency 'fsspec'|fsspec library is required"
+    with pytest.raises(ImportError, match=msg):
+        read_csv("memory://test/test.csv")
+
+
+def test_feather_options(fsspectest):
+    pytest.importorskip("pyarrow")
+    df = DataFrame({"a": [0]})
+    df.to_feather("testmem://mockfile", storage_options={"test": "feather_write"})
+    assert fsspectest.test[0] == "feather_write"
+    out = read_feather("testmem://mockfile", storage_options={"test": "feather_read"})
+    assert fsspectest.test[0] == "feather_read"
+    tm.assert_frame_equal(df, out)
+
+
+def test_pickle_options(fsspectest):
+    df = DataFrame({"a": [0]})
+    df.to_pickle("testmem://mockfile", storage_options={"test": "pickle_write"})
+    assert fsspectest.test[0] == "pickle_write"
+    out = read_pickle("testmem://mockfile", storage_options={"test": "pickle_read"})
+    assert fsspectest.test[0] == "pickle_read"
+    tm.assert_frame_equal(df, out)
+
+
+def test_json_options(fsspectest, compression):
+    df = DataFrame({"a": [0]})
+    df.to_json(
+        "testmem://mockfile",
+        compression=compression,
+        storage_options={"test": "json_write"},
+    )
+    assert fsspectest.test[0] == "json_write"
+    out = read_json(
+        "testmem://mockfile",
+        compression=compression,
+        storage_options={"test": "json_read"},
+    )
+    assert fsspectest.test[0] == "json_read"
+    tm.assert_frame_equal(df, out)
+
+
+def test_stata_options(fsspectest):
+    df = DataFrame({"a": [0]})
+    df.to_stata(
+        "testmem://mockfile", storage_options={"test": "stata_write"}, write_index=False
+    )
+    assert fsspectest.test[0] == "stata_write"
+    out = read_stata("testmem://mockfile", storage_options={"test": "stata_read"})
+    assert fsspectest.test[0] == "stata_read"
+    tm.assert_frame_equal(df, out.astype("int64"))
+
+
+def test_markdown_options(fsspectest):
+    pytest.importorskip("tabulate")
+    df = DataFrame({"a": [0]})
+    df.to_markdown("testmem://mockfile", storage_options={"test": "md_write"})
+    assert fsspectest.test[0] == "md_write"
+    assert fsspectest.cat("testmem://mockfile")
+
+
+def test_non_fsspec_options():
+    pytest.importorskip("pyarrow")
+    with pytest.raises(ValueError, match="storage_options"):
+        read_csv("localfile", storage_options={"a": True})
+    with pytest.raises(ValueError, match="storage_options"):
+        # separate test for parquet, which has a different code path
+        read_parquet("localfile", storage_options={"a": True})
+    by = io.BytesIO()
+
+    with pytest.raises(ValueError, match="storage_options"):
+        read_csv(by, storage_options={"a": True})
+
+    df = DataFrame({"a": [0]})
+    with pytest.raises(ValueError, match="storage_options"):
+        df.to_parquet("nonfsspecpath", storage_options={"a": True})

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

@@ -0,0 +1,14 @@
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_read_gbq_deprecated():
+    with tm.assert_produces_warning(FutureWarning):
+        with tm.external_error_raised(Exception):
+            pd.read_gbq("fake")
+
+
+def test_to_gbq_deprecated():
+    with tm.assert_produces_warning(FutureWarning):
+        with tm.external_error_raised(Exception):
+            pd.DataFrame(range(1)).to_gbq("fake")

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

@@ -0,0 +1,219 @@
+from io import BytesIO
+import os
+import pathlib
+import tarfile
+import zipfile
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    date_range,
+    read_csv,
+    read_excel,
+    read_json,
+    read_parquet,
+)
+import pandas._testing as tm
+from pandas.util import _test_decorators as td
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+@pytest.fixture
+def gcs_buffer():
+    """Emulate GCS using a binary buffer."""
+    pytest.importorskip("gcsfs")
+    fsspec = pytest.importorskip("fsspec")
+
+    gcs_buffer = BytesIO()
+    gcs_buffer.close = lambda: True
+
+    class MockGCSFileSystem(fsspec.AbstractFileSystem):
+        @staticmethod
+        def open(*args, **kwargs):
+            gcs_buffer.seek(0)
+            return gcs_buffer
+
+        def ls(self, path, **kwargs):
+            # needed for pyarrow
+            return [{"name": path, "type": "file"}]
+
+    # Overwrites the default implementation from gcsfs to our mock class
+    fsspec.register_implementation("gs", MockGCSFileSystem, clobber=True)
+
+    return gcs_buffer
+
+
+# Patches pyarrow; other processes should not pick up change
+@pytest.mark.single_cpu
+@pytest.mark.parametrize("format", ["csv", "json", "parquet", "excel", "markdown"])
+def test_to_read_gcs(gcs_buffer, format, monkeypatch, capsys):
+    """
+    Test that many to/read functions support GCS.
+
+    GH 33987
+    """
+
+    df1 = DataFrame(
+        {
+            "int": [1, 3],
+            "float": [2.0, np.nan],
+            "str": ["t", "s"],
+            "dt": date_range("2018-06-18", periods=2),
+        }
+    )
+
+    path = f"gs://test/test.{format}"
+
+    if format == "csv":
+        df1.to_csv(path, index=True)
+        df2 = read_csv(path, parse_dates=["dt"], index_col=0)
+    elif format == "excel":
+        path = "gs://test/test.xlsx"
+        df1.to_excel(path)
+        df2 = read_excel(path, parse_dates=["dt"], index_col=0)
+    elif format == "json":
+        df1.to_json(path)
+        df2 = read_json(path, convert_dates=["dt"])
+    elif format == "parquet":
+        pytest.importorskip("pyarrow")
+        pa_fs = pytest.importorskip("pyarrow.fs")
+
+        class MockFileSystem(pa_fs.FileSystem):
+            @staticmethod
+            def from_uri(path):
+                print("Using pyarrow filesystem")
+                to_local = pathlib.Path(path.replace("gs://", "")).absolute().as_uri()
+                return pa_fs.LocalFileSystem(to_local)
+
+        with monkeypatch.context() as m:
+            m.setattr(pa_fs, "FileSystem", MockFileSystem)
+            df1.to_parquet(path)
+            df2 = read_parquet(path)
+        captured = capsys.readouterr()
+        assert captured.out == "Using pyarrow filesystem\nUsing pyarrow filesystem\n"
+    elif format == "markdown":
+        pytest.importorskip("tabulate")
+        df1.to_markdown(path)
+        df2 = df1
+
+    tm.assert_frame_equal(df1, df2)
+
+
+def assert_equal_zip_safe(result: bytes, expected: bytes, compression: str):
+    """
+    For zip compression, only compare the CRC-32 checksum of the file contents
+    to avoid checking the time-dependent last-modified timestamp which
+    in some CI builds is off-by-one
+
+    See https://en.wikipedia.org/wiki/ZIP_(file_format)#File_headers
+    """
+    if compression == "zip":
+        # Only compare the CRC checksum of the file contents
+        with zipfile.ZipFile(BytesIO(result)) as exp, zipfile.ZipFile(
+            BytesIO(expected)
+        ) as res:
+            for res_info, exp_info in zip(res.infolist(), exp.infolist()):
+                assert res_info.CRC == exp_info.CRC
+    elif compression == "tar":
+        with tarfile.open(fileobj=BytesIO(result)) as tar_exp, tarfile.open(
+            fileobj=BytesIO(expected)
+        ) as tar_res:
+            for tar_res_info, tar_exp_info in zip(
+                tar_res.getmembers(), tar_exp.getmembers()
+            ):
+                actual_file = tar_res.extractfile(tar_res_info)
+                expected_file = tar_exp.extractfile(tar_exp_info)
+                assert (actual_file is None) == (expected_file is None)
+                if actual_file is not None and expected_file is not None:
+                    assert actual_file.read() == expected_file.read()
+    else:
+        assert result == expected
+
+
+@pytest.mark.parametrize("encoding", ["utf-8", "cp1251"])
+def test_to_csv_compression_encoding_gcs(
+    gcs_buffer, compression_only, encoding, compression_to_extension
+):
+    """
+    Compression and encoding should with GCS.
+
+    GH 35677 (to_csv, compression), GH 26124 (to_csv, encoding), and
+    GH 32392 (read_csv, encoding)
+    """
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+
+    # reference of compressed and encoded file
+    compression = {"method": compression_only}
+    if compression_only == "gzip":
+        compression["mtime"] = 1  # be reproducible
+    buffer = BytesIO()
+    df.to_csv(buffer, compression=compression, encoding=encoding, mode="wb")
+
+    # write compressed file with explicit compression
+    path_gcs = "gs://test/test.csv"
+    df.to_csv(path_gcs, compression=compression, encoding=encoding)
+    res = gcs_buffer.getvalue()
+    expected = buffer.getvalue()
+    assert_equal_zip_safe(res, expected, compression_only)
+
+    read_df = read_csv(
+        path_gcs, index_col=0, compression=compression_only, encoding=encoding
+    )
+    tm.assert_frame_equal(df, read_df)
+
+    # write compressed file with implicit compression
+    file_ext = compression_to_extension[compression_only]
+    compression["method"] = "infer"
+    path_gcs += f".{file_ext}"
+    df.to_csv(path_gcs, compression=compression, encoding=encoding)
+
+    res = gcs_buffer.getvalue()
+    expected = buffer.getvalue()
+    assert_equal_zip_safe(res, expected, compression_only)
+
+    read_df = read_csv(path_gcs, index_col=0, compression="infer", encoding=encoding)
+    tm.assert_frame_equal(df, read_df)
+
+
+def test_to_parquet_gcs_new_file(monkeypatch, tmpdir):
+    """Regression test for writing to a not-yet-existent GCS Parquet file."""
+    pytest.importorskip("fastparquet")
+    pytest.importorskip("gcsfs")
+
+    from fsspec import AbstractFileSystem
+
+    df1 = DataFrame(
+        {
+            "int": [1, 3],
+            "float": [2.0, np.nan],
+            "str": ["t", "s"],
+            "dt": date_range("2018-06-18", periods=2),
+        }
+    )
+
+    class MockGCSFileSystem(AbstractFileSystem):
+        def open(self, path, mode="r", *args):
+            if "w" not in mode:
+                raise FileNotFoundError
+            return open(os.path.join(tmpdir, "test.parquet"), mode, encoding="utf-8")
+
+    monkeypatch.setattr("gcsfs.GCSFileSystem", MockGCSFileSystem)
+    df1.to_parquet(
+        "gs://test/test.csv", index=True, engine="fastparquet", compression=None
+    )
+
+
+@td.skip_if_installed("gcsfs")
+def test_gcs_not_present_exception():
+    with tm.external_error_raised(ImportError):
+        read_csv("gs://test/test.csv")

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

@@ -0,0 +1,1657 @@
+from collections.abc import Iterator
+from functools import partial
+from io import (
+    BytesIO,
+    StringIO,
+)
+import os
+from pathlib import Path
+import re
+import threading
+from urllib.error import URLError
+
+import numpy as np
+import pytest
+
+from pandas.compat import is_platform_windows
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    NA,
+    DataFrame,
+    MultiIndex,
+    Series,
+    Timestamp,
+    date_range,
+    read_csv,
+    read_html,
+    to_datetime,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    ArrowStringArray,
+    StringArray,
+)
+
+from pandas.io.common import file_path_to_url
+
+
+@pytest.fixture(
+    params=[
+        "chinese_utf-16.html",
+        "chinese_utf-32.html",
+        "chinese_utf-8.html",
+        "letz_latin1.html",
+    ]
+)
+def html_encoding_file(request, datapath):
+    """Parametrized fixture for HTML encoding test filenames."""
+    return datapath("io", "data", "html_encoding", request.param)
+
+
+def assert_framelist_equal(list1, list2, *args, **kwargs):
+    assert len(list1) == len(list2), (
+        "lists are not of equal size "
+        f"len(list1) == {len(list1)}, "
+        f"len(list2) == {len(list2)}"
+    )
+    msg = "not all list elements are DataFrames"
+    both_frames = all(
+        map(
+            lambda x, y: isinstance(x, DataFrame) and isinstance(y, DataFrame),
+            list1,
+            list2,
+        )
+    )
+    assert both_frames, msg
+    for frame_i, frame_j in zip(list1, list2):
+        tm.assert_frame_equal(frame_i, frame_j, *args, **kwargs)
+        assert not frame_i.empty, "frames are both empty"
+
+
+def test_bs4_version_fails(monkeypatch, datapath):
+    bs4 = pytest.importorskip("bs4")
+    pytest.importorskip("html5lib")
+
+    monkeypatch.setattr(bs4, "__version__", "4.2")
+    with pytest.raises(ImportError, match="Pandas requires version"):
+        read_html(datapath("io", "data", "html", "spam.html"), flavor="bs4")
+
+
+def test_invalid_flavor():
+    url = "google.com"
+    flavor = "invalid flavor"
+    msg = r"\{" + flavor + r"\} is not a valid set of flavors"
+
+    with pytest.raises(ValueError, match=msg):
+        read_html(StringIO(url), match="google", flavor=flavor)
+
+
+def test_same_ordering(datapath):
+    pytest.importorskip("bs4")
+    pytest.importorskip("lxml")
+    pytest.importorskip("html5lib")
+
+    filename = datapath("io", "data", "html", "valid_markup.html")
+    dfs_lxml = read_html(filename, index_col=0, flavor=["lxml"])
+    dfs_bs4 = read_html(filename, index_col=0, flavor=["bs4"])
+    assert_framelist_equal(dfs_lxml, dfs_bs4)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param("bs4", marks=[td.skip_if_no("bs4"), td.skip_if_no("html5lib")]),
+        pytest.param("lxml", marks=td.skip_if_no("lxml")),
+    ],
+)
+def flavor_read_html(request):
+    return partial(read_html, flavor=request.param)
+
+
+class TestReadHtml:
+    def test_literal_html_deprecation(self, flavor_read_html):
+        # GH 53785
+        msg = (
+            "Passing literal html to 'read_html' is deprecated and "
+            "will be removed in a future version. To read from a "
+            "literal string, wrap it in a 'StringIO' object."
+        )
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            flavor_read_html(
+                """<table>
+                <thead>
+                    <tr>
+                        <th>A</th>
+                        <th>B</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>1</td>
+                        <td>2</td>
+                    </tr>
+                </tbody>
+                <tbody>
+                    <tr>
+                        <td>3</td>
+                        <td>4</td>
+                    </tr>
+                </tbody>
+            </table>"""
+            )
+
+    @pytest.fixture
+    def spam_data(self, datapath):
+        return datapath("io", "data", "html", "spam.html")
+
+    @pytest.fixture
+    def banklist_data(self, datapath):
+        return datapath("io", "data", "html", "banklist.html")
+
+    def test_to_html_compat(self, flavor_read_html):
+        df = (
+            DataFrame(
+                np.random.default_rng(2).random((4, 3)),
+                columns=pd.Index(list("abc"), dtype=object),
+            )
+            # pylint: disable-next=consider-using-f-string
+            .map("{:.3f}".format).astype(float)
+        )
+        out = df.to_html()
+        res = flavor_read_html(
+            StringIO(out), attrs={"class": "dataframe"}, index_col=0
+        )[0]
+        tm.assert_frame_equal(res, df)
+
+    def test_dtype_backend(self, string_storage, dtype_backend, flavor_read_html):
+        # GH#50286
+        df = DataFrame(
+            {
+                "a": Series([1, np.nan, 3], dtype="Int64"),
+                "b": Series([1, 2, 3], dtype="Int64"),
+                "c": Series([1.5, np.nan, 2.5], dtype="Float64"),
+                "d": Series([1.5, 2.0, 2.5], dtype="Float64"),
+                "e": [True, False, None],
+                "f": [True, False, True],
+                "g": ["a", "b", "c"],
+                "h": ["a", "b", None],
+            }
+        )
+
+        if string_storage == "python":
+            string_array = StringArray(np.array(["a", "b", "c"], dtype=np.object_))
+            string_array_na = StringArray(np.array(["a", "b", NA], dtype=np.object_))
+        elif dtype_backend == "pyarrow":
+            pa = pytest.importorskip("pyarrow")
+            from pandas.arrays import ArrowExtensionArray
+
+            string_array = ArrowExtensionArray(pa.array(["a", "b", "c"]))
+            string_array_na = ArrowExtensionArray(pa.array(["a", "b", None]))
+        else:
+            pa = pytest.importorskip("pyarrow")
+            string_array = ArrowStringArray(pa.array(["a", "b", "c"]))
+            string_array_na = ArrowStringArray(pa.array(["a", "b", None]))
+
+        out = df.to_html(index=False)
+        with pd.option_context("mode.string_storage", string_storage):
+            result = flavor_read_html(StringIO(out), dtype_backend=dtype_backend)[0]
+
+        expected = DataFrame(
+            {
+                "a": Series([1, np.nan, 3], dtype="Int64"),
+                "b": Series([1, 2, 3], dtype="Int64"),
+                "c": Series([1.5, np.nan, 2.5], dtype="Float64"),
+                "d": Series([1.5, 2.0, 2.5], dtype="Float64"),
+                "e": Series([True, False, NA], dtype="boolean"),
+                "f": Series([True, False, True], dtype="boolean"),
+                "g": string_array,
+                "h": string_array_na,
+            }
+        )
+
+        if dtype_backend == "pyarrow":
+            import pyarrow as pa
+
+            from pandas.arrays import ArrowExtensionArray
+
+            expected = DataFrame(
+                {
+                    col: ArrowExtensionArray(pa.array(expected[col], from_pandas=True))
+                    for col in expected.columns
+                }
+            )
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    def test_banklist_url(self, httpserver, banklist_data, flavor_read_html):
+        with open(banklist_data, encoding="utf-8") as f:
+            httpserver.serve_content(content=f.read())
+            df1 = flavor_read_html(
+                # lxml cannot find attrs leave out for now
+                httpserver.url,
+                match="First Federal Bank of Florida",  # attrs={"class": "dataTable"}
+            )
+            # lxml cannot find attrs leave out for now
+            df2 = flavor_read_html(
+                httpserver.url,
+                match="Metcalf Bank",
+            )  # attrs={"class": "dataTable"})
+
+        assert_framelist_equal(df1, df2)
+
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    def test_spam_url(self, httpserver, spam_data, flavor_read_html):
+        with open(spam_data, encoding="utf-8") as f:
+            httpserver.serve_content(content=f.read())
+            df1 = flavor_read_html(httpserver.url, match=".*Water.*")
+            df2 = flavor_read_html(httpserver.url, match="Unit")
+
+        assert_framelist_equal(df1, df2)
+
+    @pytest.mark.slow
+    def test_banklist(self, banklist_data, flavor_read_html):
+        df1 = flavor_read_html(
+            banklist_data, match=".*Florida.*", attrs={"id": "table"}
+        )
+        df2 = flavor_read_html(
+            banklist_data, match="Metcalf Bank", attrs={"id": "table"}
+        )
+
+        assert_framelist_equal(df1, df2)
+
+    def test_spam(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*")
+        df2 = flavor_read_html(spam_data, match="Unit")
+        assert_framelist_equal(df1, df2)
+
+        assert df1[0].iloc[0, 0] == "Proximates"
+        assert df1[0].columns[0] == "Nutrient"
+
+    def test_spam_no_match(self, spam_data, flavor_read_html):
+        dfs = flavor_read_html(spam_data)
+        for df in dfs:
+            assert isinstance(df, DataFrame)
+
+    def test_banklist_no_match(self, banklist_data, flavor_read_html):
+        dfs = flavor_read_html(banklist_data, attrs={"id": "table"})
+        for df in dfs:
+            assert isinstance(df, DataFrame)
+
+    def test_spam_header(self, spam_data, flavor_read_html):
+        df = flavor_read_html(spam_data, match=".*Water.*", header=2)[0]
+        assert df.columns[0] == "Proximates"
+        assert not df.empty
+
+    def test_skiprows_int(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", skiprows=1)
+        df2 = flavor_read_html(spam_data, match="Unit", skiprows=1)
+
+        assert_framelist_equal(df1, df2)
+
+    def test_skiprows_range(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", skiprows=range(2))
+        df2 = flavor_read_html(spam_data, match="Unit", skiprows=range(2))
+
+        assert_framelist_equal(df1, df2)
+
+    def test_skiprows_list(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", skiprows=[1, 2])
+        df2 = flavor_read_html(spam_data, match="Unit", skiprows=[2, 1])
+
+        assert_framelist_equal(df1, df2)
+
+    def test_skiprows_set(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", skiprows={1, 2})
+        df2 = flavor_read_html(spam_data, match="Unit", skiprows={2, 1})
+
+        assert_framelist_equal(df1, df2)
+
+    def test_skiprows_slice(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", skiprows=1)
+        df2 = flavor_read_html(spam_data, match="Unit", skiprows=1)
+
+        assert_framelist_equal(df1, df2)
+
+    def test_skiprows_slice_short(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", skiprows=slice(2))
+        df2 = flavor_read_html(spam_data, match="Unit", skiprows=slice(2))
+
+        assert_framelist_equal(df1, df2)
+
+    def test_skiprows_slice_long(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", skiprows=slice(2, 5))
+        df2 = flavor_read_html(spam_data, match="Unit", skiprows=slice(4, 1, -1))
+
+        assert_framelist_equal(df1, df2)
+
+    def test_skiprows_ndarray(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", skiprows=np.arange(2))
+        df2 = flavor_read_html(spam_data, match="Unit", skiprows=np.arange(2))
+
+        assert_framelist_equal(df1, df2)
+
+    def test_skiprows_invalid(self, spam_data, flavor_read_html):
+        with pytest.raises(TypeError, match=("is not a valid type for skipping rows")):
+            flavor_read_html(spam_data, match=".*Water.*", skiprows="asdf")
+
+    def test_index(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", index_col=0)
+        df2 = flavor_read_html(spam_data, match="Unit", index_col=0)
+        assert_framelist_equal(df1, df2)
+
+    def test_header_and_index_no_types(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", header=1, index_col=0)
+        df2 = flavor_read_html(spam_data, match="Unit", header=1, index_col=0)
+        assert_framelist_equal(df1, df2)
+
+    def test_header_and_index_with_types(self, spam_data, flavor_read_html):
+        df1 = flavor_read_html(spam_data, match=".*Water.*", header=1, index_col=0)
+        df2 = flavor_read_html(spam_data, match="Unit", header=1, index_col=0)
+        assert_framelist_equal(df1, df2)
+
+    def test_infer_types(self, spam_data, flavor_read_html):
+        # 10892 infer_types removed
+        df1 = flavor_read_html(spam_data, match=".*Water.*", index_col=0)
+        df2 = flavor_read_html(spam_data, match="Unit", index_col=0)
+        assert_framelist_equal(df1, df2)
+
+    def test_string_io(self, spam_data, flavor_read_html):
+        with open(spam_data, encoding="UTF-8") as f:
+            data1 = StringIO(f.read())
+
+        with open(spam_data, encoding="UTF-8") as f:
+            data2 = StringIO(f.read())
+
+        df1 = flavor_read_html(data1, match=".*Water.*")
+        df2 = flavor_read_html(data2, match="Unit")
+        assert_framelist_equal(df1, df2)
+
+    def test_string(self, spam_data, flavor_read_html):
+        with open(spam_data, encoding="UTF-8") as f:
+            data = f.read()
+
+        df1 = flavor_read_html(StringIO(data), match=".*Water.*")
+        df2 = flavor_read_html(StringIO(data), match="Unit")
+
+        assert_framelist_equal(df1, df2)
+
+    def test_file_like(self, spam_data, flavor_read_html):
+        with open(spam_data, encoding="UTF-8") as f:
+            df1 = flavor_read_html(f, match=".*Water.*")
+
+        with open(spam_data, encoding="UTF-8") as f:
+            df2 = flavor_read_html(f, match="Unit")
+
+        assert_framelist_equal(df1, df2)
+
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    def test_bad_url_protocol(self, httpserver, flavor_read_html):
+        httpserver.serve_content("urlopen error unknown url type: git", code=404)
+        with pytest.raises(URLError, match="urlopen error unknown url type: git"):
+            flavor_read_html("git://github.com", match=".*Water.*")
+
+    @pytest.mark.slow
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    def test_invalid_url(self, httpserver, flavor_read_html):
+        httpserver.serve_content("Name or service not known", code=404)
+        with pytest.raises((URLError, ValueError), match="HTTP Error 404: NOT FOUND"):
+            flavor_read_html(httpserver.url, match=".*Water.*")
+
+    @pytest.mark.slow
+    def test_file_url(self, banklist_data, flavor_read_html):
+        url = banklist_data
+        dfs = flavor_read_html(
+            file_path_to_url(os.path.abspath(url)), match="First", attrs={"id": "table"}
+        )
+        assert isinstance(dfs, list)
+        for df in dfs:
+            assert isinstance(df, DataFrame)
+
+    @pytest.mark.slow
+    def test_invalid_table_attrs(self, banklist_data, flavor_read_html):
+        url = banklist_data
+        with pytest.raises(ValueError, match="No tables found"):
+            flavor_read_html(
+                url, match="First Federal Bank of Florida", attrs={"id": "tasdfable"}
+            )
+
+    @pytest.mark.slow
+    def test_multiindex_header(self, banklist_data, flavor_read_html):
+        df = flavor_read_html(
+            banklist_data, match="Metcalf", attrs={"id": "table"}, header=[0, 1]
+        )[0]
+        assert isinstance(df.columns, MultiIndex)
+
+    @pytest.mark.slow
+    def test_multiindex_index(self, banklist_data, flavor_read_html):
+        df = flavor_read_html(
+            banklist_data, match="Metcalf", attrs={"id": "table"}, index_col=[0, 1]
+        )[0]
+        assert isinstance(df.index, MultiIndex)
+
+    @pytest.mark.slow
+    def test_multiindex_header_index(self, banklist_data, flavor_read_html):
+        df = flavor_read_html(
+            banklist_data,
+            match="Metcalf",
+            attrs={"id": "table"},
+            header=[0, 1],
+            index_col=[0, 1],
+        )[0]
+        assert isinstance(df.columns, MultiIndex)
+        assert isinstance(df.index, MultiIndex)
+
+    @pytest.mark.slow
+    def test_multiindex_header_skiprows_tuples(self, banklist_data, flavor_read_html):
+        df = flavor_read_html(
+            banklist_data,
+            match="Metcalf",
+            attrs={"id": "table"},
+            header=[0, 1],
+            skiprows=1,
+        )[0]
+        assert isinstance(df.columns, MultiIndex)
+
+    @pytest.mark.slow
+    def test_multiindex_header_skiprows(self, banklist_data, flavor_read_html):
+        df = flavor_read_html(
+            banklist_data,
+            match="Metcalf",
+            attrs={"id": "table"},
+            header=[0, 1],
+            skiprows=1,
+        )[0]
+        assert isinstance(df.columns, MultiIndex)
+
+    @pytest.mark.slow
+    def test_multiindex_header_index_skiprows(self, banklist_data, flavor_read_html):
+        df = flavor_read_html(
+            banklist_data,
+            match="Metcalf",
+            attrs={"id": "table"},
+            header=[0, 1],
+            index_col=[0, 1],
+            skiprows=1,
+        )[0]
+        assert isinstance(df.index, MultiIndex)
+        assert isinstance(df.columns, MultiIndex)
+
+    @pytest.mark.slow
+    def test_regex_idempotency(self, banklist_data, flavor_read_html):
+        url = banklist_data
+        dfs = flavor_read_html(
+            file_path_to_url(os.path.abspath(url)),
+            match=re.compile(re.compile("Florida")),
+            attrs={"id": "table"},
+        )
+        assert isinstance(dfs, list)
+        for df in dfs:
+            assert isinstance(df, DataFrame)
+
+    def test_negative_skiprows(self, spam_data, flavor_read_html):
+        msg = r"\(you passed a negative value\)"
+        with pytest.raises(ValueError, match=msg):
+            flavor_read_html(spam_data, match="Water", skiprows=-1)
+
+    @pytest.fixture
+    def python_docs(self):
+        return """
+          <table class="contentstable" align="center"><tr>
+            <td width="50%">
+            <p class="biglink"><a class="biglink" href="whatsnew/2.7.html">What's new in Python 2.7?</a><br/>
+                <span class="linkdescr">or <a href="whatsnew/index.html">all "What's new" documents</a> since 2.0</span></p>
+            <p class="biglink"><a class="biglink" href="tutorial/index.html">Tutorial</a><br/>
+                <span class="linkdescr">start here</span></p>
+            <p class="biglink"><a class="biglink" href="library/index.html">Library Reference</a><br/>
+                <span class="linkdescr">keep this under your pillow</span></p>
+            <p class="biglink"><a class="biglink" href="reference/index.html">Language Reference</a><br/>
+                <span class="linkdescr">describes syntax and language elements</span></p>
+            <p class="biglink"><a class="biglink" href="using/index.html">Python Setup and Usage</a><br/>
+                <span class="linkdescr">how to use Python on different platforms</span></p>
+            <p class="biglink"><a class="biglink" href="howto/index.html">Python HOWTOs</a><br/>
+                <span class="linkdescr">in-depth documents on specific topics</span></p>
+            </td><td width="50%">
+            <p class="biglink"><a class="biglink" href="installing/index.html">Installing Python Modules</a><br/>
+                <span class="linkdescr">installing from the Python Package Index &amp; other sources</span></p>
+            <p class="biglink"><a class="biglink" href="distributing/index.html">Distributing Python Modules</a><br/>
+                <span class="linkdescr">publishing modules for installation by others</span></p>
+            <p class="biglink"><a class="biglink" href="extending/index.html">Extending and Embedding</a><br/>
+                <span class="linkdescr">tutorial for C/C++ programmers</span></p>
+            <p class="biglink"><a class="biglink" href="c-api/index.html">Python/C API</a><br/>
+                <span class="linkdescr">reference for C/C++ programmers</span></p>
+            <p class="biglink"><a class="biglink" href="faq/index.html">FAQs</a><br/>
+                <span class="linkdescr">frequently asked questions (with answers!)</span></p>
+            </td></tr>
+        </table>
+
+        <p><strong>Indices and tables:</strong></p>
+        <table class="contentstable" align="center"><tr>
+            <td width="50%">
+            <p class="biglink"><a class="biglink" href="py-modindex.html">Python Global Module Index</a><br/>
+                <span class="linkdescr">quick access to all modules</span></p>
+            <p class="biglink"><a class="biglink" href="genindex.html">General Index</a><br/>
+                <span class="linkdescr">all functions, classes, terms</span></p>
+            <p class="biglink"><a class="biglink" href="glossary.html">Glossary</a><br/>
+                <span class="linkdescr">the most important terms explained</span></p>
+            </td><td width="50%">
+            <p class="biglink"><a class="biglink" href="search.html">Search page</a><br/>
+                <span class="linkdescr">search this documentation</span></p>
+            <p class="biglink"><a class="biglink" href="contents.html">Complete Table of Contents</a><br/>
+                <span class="linkdescr">lists all sections and subsections</span></p>
+            </td></tr>
+        </table>
+        """  # noqa: E501
+
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    def test_multiple_matches(self, python_docs, httpserver, flavor_read_html):
+        httpserver.serve_content(content=python_docs)
+        dfs = flavor_read_html(httpserver.url, match="Python")
+        assert len(dfs) > 1
+
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    def test_python_docs_table(self, python_docs, httpserver, flavor_read_html):
+        httpserver.serve_content(content=python_docs)
+        dfs = flavor_read_html(httpserver.url, match="Python")
+        zz = [df.iloc[0, 0][0:4] for df in dfs]
+        assert sorted(zz) == ["Pyth", "What"]
+
+    def test_empty_tables(self, flavor_read_html):
+        """
+        Make sure that read_html ignores empty tables.
+        """
+        html = """
+            <table>
+                <thead>
+                    <tr>
+                        <th>A</th>
+                        <th>B</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>1</td>
+                        <td>2</td>
+                    </tr>
+                </tbody>
+            </table>
+            <table>
+                <tbody>
+                </tbody>
+            </table>
+        """
+        result = flavor_read_html(StringIO(html))
+        assert len(result) == 1
+
+    def test_multiple_tbody(self, flavor_read_html):
+        # GH-20690
+        # Read all tbody tags within a single table.
+        result = flavor_read_html(
+            StringIO(
+                """<table>
+            <thead>
+                <tr>
+                    <th>A</th>
+                    <th>B</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td>1</td>
+                    <td>2</td>
+                </tr>
+            </tbody>
+            <tbody>
+                <tr>
+                    <td>3</td>
+                    <td>4</td>
+                </tr>
+            </tbody>
+        </table>"""
+            )
+        )[0]
+
+        expected = DataFrame(data=[[1, 2], [3, 4]], columns=["A", "B"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_header_and_one_column(self, flavor_read_html):
+        """
+        Don't fail with bs4 when there is a header and only one column
+        as described in issue #9178
+        """
+        result = flavor_read_html(
+            StringIO(
+                """<table>
+                <thead>
+                    <tr>
+                        <th>Header</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>first</td>
+                    </tr>
+                </tbody>
+            </table>"""
+            )
+        )[0]
+
+        expected = DataFrame(data={"Header": "first"}, index=[0])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_thead_without_tr(self, flavor_read_html):
+        """
+        Ensure parser adds <tr> within <thead> on malformed HTML.
+        """
+        result = flavor_read_html(
+            StringIO(
+                """<table>
+            <thead>
+                <tr>
+                    <th>Country</th>
+                    <th>Municipality</th>
+                    <th>Year</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td>Ukraine</td>
+                    <th>Odessa</th>
+                    <td>1944</td>
+                </tr>
+            </tbody>
+        </table>"""
+            )
+        )[0]
+
+        expected = DataFrame(
+            data=[["Ukraine", "Odessa", 1944]],
+            columns=["Country", "Municipality", "Year"],
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_tfoot_read(self, flavor_read_html):
+        """
+        Make sure that read_html reads tfoot, containing td or th.
+        Ignores empty tfoot
+        """
+        data_template = """<table>
+            <thead>
+                <tr>
+                    <th>A</th>
+                    <th>B</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td>bodyA</td>
+                    <td>bodyB</td>
+                </tr>
+            </tbody>
+            <tfoot>
+                {footer}
+            </tfoot>
+        </table>"""
+
+        expected1 = DataFrame(data=[["bodyA", "bodyB"]], columns=["A", "B"])
+
+        expected2 = DataFrame(
+            data=[["bodyA", "bodyB"], ["footA", "footB"]], columns=["A", "B"]
+        )
+
+        data1 = data_template.format(footer="")
+        data2 = data_template.format(footer="<tr><td>footA</td><th>footB</th></tr>")
+
+        result1 = flavor_read_html(StringIO(data1))[0]
+        result2 = flavor_read_html(StringIO(data2))[0]
+
+        tm.assert_frame_equal(result1, expected1)
+        tm.assert_frame_equal(result2, expected2)
+
+    def test_parse_header_of_non_string_column(self, flavor_read_html):
+        # GH5048: if header is specified explicitly, an int column should be
+        # parsed as int while its header is parsed as str
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <tr>
+                    <td>S</td>
+                    <td>I</td>
+                </tr>
+                <tr>
+                    <td>text</td>
+                    <td>1944</td>
+                </tr>
+            </table>
+        """
+            ),
+            header=0,
+        )[0]
+
+        expected = DataFrame([["text", 1944]], columns=("S", "I"))
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.slow
+    def test_banklist_header(self, banklist_data, datapath, flavor_read_html):
+        from pandas.io.html import _remove_whitespace
+
+        def try_remove_ws(x):
+            try:
+                return _remove_whitespace(x)
+            except AttributeError:
+                return x
+
+        df = flavor_read_html(banklist_data, match="Metcalf", attrs={"id": "table"})[0]
+        ground_truth = read_csv(
+            datapath("io", "data", "csv", "banklist.csv"),
+            converters={"Updated Date": Timestamp, "Closing Date": Timestamp},
+        )
+        assert df.shape == ground_truth.shape
+        old = [
+            "First Vietnamese American Bank In Vietnamese",
+            "Westernbank Puerto Rico En Espanol",
+            "R-G Premier Bank of Puerto Rico En Espanol",
+            "Eurobank En Espanol",
+            "Sanderson State Bank En Espanol",
+            "Washington Mutual Bank (Including its subsidiary Washington "
+            "Mutual Bank FSB)",
+            "Silver State Bank En Espanol",
+            "AmTrade International Bank En Espanol",
+            "Hamilton Bank, NA En Espanol",
+            "The Citizens Savings Bank Pioneer Community Bank, Inc.",
+        ]
+        new = [
+            "First Vietnamese American Bank",
+            "Westernbank Puerto Rico",
+            "R-G Premier Bank of Puerto Rico",
+            "Eurobank",
+            "Sanderson State Bank",
+            "Washington Mutual Bank",
+            "Silver State Bank",
+            "AmTrade International Bank",
+            "Hamilton Bank, NA",
+            "The Citizens Savings Bank",
+        ]
+        dfnew = df.map(try_remove_ws).replace(old, new)
+        gtnew = ground_truth.map(try_remove_ws)
+        converted = dfnew
+        date_cols = ["Closing Date", "Updated Date"]
+        converted[date_cols] = converted[date_cols].apply(to_datetime)
+        tm.assert_frame_equal(converted, gtnew)
+
+    @pytest.mark.slow
+    def test_gold_canyon(self, banklist_data, flavor_read_html):
+        gc = "Gold Canyon"
+        with open(banklist_data, encoding="utf-8") as f:
+            raw_text = f.read()
+
+        assert gc in raw_text
+        df = flavor_read_html(
+            banklist_data, match="Gold Canyon", attrs={"id": "table"}
+        )[0]
+        assert gc in df.to_string()
+
+    def test_different_number_of_cols(self, flavor_read_html):
+        expected = flavor_read_html(
+            StringIO(
+                """<table>
+                        <thead>
+                            <tr style="text-align: right;">
+                            <th></th>
+                            <th>C_l0_g0</th>
+                            <th>C_l0_g1</th>
+                            <th>C_l0_g2</th>
+                            <th>C_l0_g3</th>
+                            <th>C_l0_g4</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr>
+                            <th>R_l0_g0</th>
+                            <td> 0.763</td>
+                            <td> 0.233</td>
+                            <td> nan</td>
+                            <td> nan</td>
+                            <td> nan</td>
+                            </tr>
+                            <tr>
+                            <th>R_l0_g1</th>
+                            <td> 0.244</td>
+                            <td> 0.285</td>
+                            <td> 0.392</td>
+                            <td> 0.137</td>
+                            <td> 0.222</td>
+                            </tr>
+                        </tbody>
+                    </table>"""
+            ),
+            index_col=0,
+        )[0]
+
+        result = flavor_read_html(
+            StringIO(
+                """<table>
+                    <thead>
+                        <tr style="text-align: right;">
+                        <th></th>
+                        <th>C_l0_g0</th>
+                        <th>C_l0_g1</th>
+                        <th>C_l0_g2</th>
+                        <th>C_l0_g3</th>
+                        <th>C_l0_g4</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        <tr>
+                        <th>R_l0_g0</th>
+                        <td> 0.763</td>
+                        <td> 0.233</td>
+                        </tr>
+                        <tr>
+                        <th>R_l0_g1</th>
+                        <td> 0.244</td>
+                        <td> 0.285</td>
+                        <td> 0.392</td>
+                        <td> 0.137</td>
+                        <td> 0.222</td>
+                        </tr>
+                    </tbody>
+                 </table>"""
+            ),
+            index_col=0,
+        )[0]
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_colspan_rowspan_1(self, flavor_read_html):
+        # GH17054
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <tr>
+                    <th>A</th>
+                    <th colspan="1">B</th>
+                    <th rowspan="1">C</th>
+                </tr>
+                <tr>
+                    <td>a</td>
+                    <td>b</td>
+                    <td>c</td>
+                </tr>
+            </table>
+        """
+            )
+        )[0]
+
+        expected = DataFrame([["a", "b", "c"]], columns=["A", "B", "C"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_colspan_rowspan_copy_values(self, flavor_read_html):
+        # GH17054
+
+        # In ASCII, with lowercase letters being copies:
+        #
+        # X x Y Z W
+        # A B b z C
+
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <tr>
+                    <td colspan="2">X</td>
+                    <td>Y</td>
+                    <td rowspan="2">Z</td>
+                    <td>W</td>
+                </tr>
+                <tr>
+                    <td>A</td>
+                    <td colspan="2">B</td>
+                    <td>C</td>
+                </tr>
+            </table>
+        """
+            ),
+            header=0,
+        )[0]
+
+        expected = DataFrame(
+            data=[["A", "B", "B", "Z", "C"]], columns=["X", "X.1", "Y", "Z", "W"]
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_colspan_rowspan_both_not_1(self, flavor_read_html):
+        # GH17054
+
+        # In ASCII, with lowercase letters being copies:
+        #
+        # A B b b C
+        # a b b b D
+
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <tr>
+                    <td rowspan="2">A</td>
+                    <td rowspan="2" colspan="3">B</td>
+                    <td>C</td>
+                </tr>
+                <tr>
+                    <td>D</td>
+                </tr>
+            </table>
+        """
+            ),
+            header=0,
+        )[0]
+
+        expected = DataFrame(
+            data=[["A", "B", "B", "B", "D"]], columns=["A", "B", "B.1", "B.2", "C"]
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_rowspan_at_end_of_row(self, flavor_read_html):
+        # GH17054
+
+        # In ASCII, with lowercase letters being copies:
+        #
+        # A B
+        # C b
+
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <tr>
+                    <td>A</td>
+                    <td rowspan="2">B</td>
+                </tr>
+                <tr>
+                    <td>C</td>
+                </tr>
+            </table>
+        """
+            ),
+            header=0,
+        )[0]
+
+        expected = DataFrame(data=[["C", "B"]], columns=["A", "B"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_rowspan_only_rows(self, flavor_read_html):
+        # GH17054
+
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <tr>
+                    <td rowspan="3">A</td>
+                    <td rowspan="3">B</td>
+                </tr>
+            </table>
+        """
+            ),
+            header=0,
+        )[0]
+
+        expected = DataFrame(data=[["A", "B"], ["A", "B"]], columns=["A", "B"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_header_inferred_from_rows_with_only_th(self, flavor_read_html):
+        # GH17054
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <tr>
+                    <th>A</th>
+                    <th>B</th>
+                </tr>
+                <tr>
+                    <th>a</th>
+                    <th>b</th>
+                </tr>
+                <tr>
+                    <td>1</td>
+                    <td>2</td>
+                </tr>
+            </table>
+        """
+            )
+        )[0]
+
+        columns = MultiIndex(levels=[["A", "B"], ["a", "b"]], codes=[[0, 1], [0, 1]])
+        expected = DataFrame(data=[[1, 2]], columns=columns)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_parse_dates_list(self, flavor_read_html):
+        df = DataFrame({"date": date_range("1/1/2001", periods=10)})
+        expected = df.to_html()
+        res = flavor_read_html(StringIO(expected), parse_dates=[1], index_col=0)
+        tm.assert_frame_equal(df, res[0])
+        res = flavor_read_html(StringIO(expected), parse_dates=["date"], index_col=0)
+        tm.assert_frame_equal(df, res[0])
+
+    def test_parse_dates_combine(self, flavor_read_html):
+        raw_dates = Series(date_range("1/1/2001", periods=10))
+        df = DataFrame(
+            {
+                "date": raw_dates.map(lambda x: str(x.date())),
+                "time": raw_dates.map(lambda x: str(x.time())),
+            }
+        )
+        res = flavor_read_html(
+            StringIO(df.to_html()), parse_dates={"datetime": [1, 2]}, index_col=1
+        )
+        newdf = DataFrame({"datetime": raw_dates})
+        tm.assert_frame_equal(newdf, res[0])
+
+    def test_wikipedia_states_table(self, datapath, flavor_read_html):
+        data = datapath("io", "data", "html", "wikipedia_states.html")
+        assert os.path.isfile(data), f"{repr(data)} is not a file"
+        assert os.path.getsize(data), f"{repr(data)} is an empty file"
+        result = flavor_read_html(data, match="Arizona", header=1)[0]
+        assert result.shape == (60, 12)
+        assert "Unnamed" in result.columns[-1]
+        assert result["sq mi"].dtype == np.dtype("float64")
+        assert np.allclose(result.loc[0, "sq mi"], 665384.04)
+
+    def test_wikipedia_states_multiindex(self, datapath, flavor_read_html):
+        data = datapath("io", "data", "html", "wikipedia_states.html")
+        result = flavor_read_html(data, match="Arizona", index_col=0)[0]
+        assert result.shape == (60, 11)
+        assert "Unnamed" in result.columns[-1][1]
+        assert result.columns.nlevels == 2
+        assert np.allclose(result.loc["Alaska", ("Total area[2]", "sq mi")], 665384.04)
+
+    def test_parser_error_on_empty_header_row(self, flavor_read_html):
+        result = flavor_read_html(
+            StringIO(
+                """
+                <table>
+                    <thead>
+                        <tr><th></th><th></tr>
+                        <tr><th>A</th><th>B</th></tr>
+                    </thead>
+                    <tbody>
+                        <tr><td>a</td><td>b</td></tr>
+                    </tbody>
+                </table>
+            """
+            ),
+            header=[0, 1],
+        )
+        expected = DataFrame(
+            [["a", "b"]],
+            columns=MultiIndex.from_tuples(
+                [("Unnamed: 0_level_0", "A"), ("Unnamed: 1_level_0", "B")]
+            ),
+        )
+        tm.assert_frame_equal(result[0], expected)
+
+    def test_decimal_rows(self, flavor_read_html):
+        # GH 12907
+        result = flavor_read_html(
+            StringIO(
+                """<html>
+            <body>
+             <table>
+                <thead>
+                    <tr>
+                        <th>Header</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>1100#101</td>
+                    </tr>
+                </tbody>
+            </table>
+            </body>
+        </html>"""
+            ),
+            decimal="#",
+        )[0]
+
+        expected = DataFrame(data={"Header": 1100.101}, index=[0])
+
+        assert result["Header"].dtype == np.dtype("float64")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("arg", [True, False])
+    def test_bool_header_arg(self, spam_data, arg, flavor_read_html):
+        # GH 6114
+        msg = re.escape(
+            "Passing a bool to header is invalid. Use header=None for no header or "
+            "header=int or list-like of ints to specify the row(s) making up the "
+            "column names"
+        )
+        with pytest.raises(TypeError, match=msg):
+            flavor_read_html(spam_data, header=arg)
+
+    def test_converters(self, flavor_read_html):
+        # GH 13461
+        result = flavor_read_html(
+            StringIO(
+                """<table>
+                 <thead>
+                   <tr>
+                     <th>a</th>
+                    </tr>
+                 </thead>
+                 <tbody>
+                   <tr>
+                     <td> 0.763</td>
+                   </tr>
+                   <tr>
+                     <td> 0.244</td>
+                   </tr>
+                 </tbody>
+               </table>"""
+            ),
+            converters={"a": str},
+        )[0]
+
+        expected = DataFrame({"a": ["0.763", "0.244"]})
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_na_values(self, flavor_read_html):
+        # GH 13461
+        result = flavor_read_html(
+            StringIO(
+                """<table>
+                 <thead>
+                   <tr>
+                     <th>a</th>
+                   </tr>
+                 </thead>
+                 <tbody>
+                   <tr>
+                     <td> 0.763</td>
+                   </tr>
+                   <tr>
+                     <td> 0.244</td>
+                   </tr>
+                 </tbody>
+               </table>"""
+            ),
+            na_values=[0.244],
+        )[0]
+
+        expected = DataFrame({"a": [0.763, np.nan]})
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_keep_default_na(self, flavor_read_html):
+        html_data = """<table>
+                        <thead>
+                            <tr>
+                            <th>a</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr>
+                            <td> N/A</td>
+                            </tr>
+                            <tr>
+                            <td> NA</td>
+                            </tr>
+                        </tbody>
+                    </table>"""
+
+        expected_df = DataFrame({"a": ["N/A", "NA"]})
+        html_df = flavor_read_html(StringIO(html_data), keep_default_na=False)[0]
+        tm.assert_frame_equal(expected_df, html_df)
+
+        expected_df = DataFrame({"a": [np.nan, np.nan]})
+        html_df = flavor_read_html(StringIO(html_data), keep_default_na=True)[0]
+        tm.assert_frame_equal(expected_df, html_df)
+
+    def test_preserve_empty_rows(self, flavor_read_html):
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <tr>
+                    <th>A</th>
+                    <th>B</th>
+                </tr>
+                <tr>
+                    <td>a</td>
+                    <td>b</td>
+                </tr>
+                <tr>
+                    <td></td>
+                    <td></td>
+                </tr>
+            </table>
+        """
+            )
+        )[0]
+
+        expected = DataFrame(data=[["a", "b"], [np.nan, np.nan]], columns=["A", "B"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_ignore_empty_rows_when_inferring_header(self, flavor_read_html):
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <thead>
+                    <tr><th></th><th></tr>
+                    <tr><th>A</th><th>B</th></tr>
+                    <tr><th>a</th><th>b</th></tr>
+                </thead>
+                <tbody>
+                    <tr><td>1</td><td>2</td></tr>
+                </tbody>
+            </table>
+        """
+            )
+        )[0]
+
+        columns = MultiIndex(levels=[["A", "B"], ["a", "b"]], codes=[[0, 1], [0, 1]])
+        expected = DataFrame(data=[[1, 2]], columns=columns)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_multiple_header_rows(self, flavor_read_html):
+        # Issue #13434
+        expected_df = DataFrame(
+            data=[("Hillary", 68, "D"), ("Bernie", 74, "D"), ("Donald", 69, "R")]
+        )
+        expected_df.columns = [
+            ["Unnamed: 0_level_0", "Age", "Party"],
+            ["Name", "Unnamed: 1_level_1", "Unnamed: 2_level_1"],
+        ]
+        html = expected_df.to_html(index=False)
+        html_df = flavor_read_html(StringIO(html))[0]
+        tm.assert_frame_equal(expected_df, html_df)
+
+    def test_works_on_valid_markup(self, datapath, flavor_read_html):
+        filename = datapath("io", "data", "html", "valid_markup.html")
+        dfs = flavor_read_html(filename, index_col=0)
+        assert isinstance(dfs, list)
+        assert isinstance(dfs[0], DataFrame)
+
+    @pytest.mark.slow
+    def test_fallback_success(self, datapath, flavor_read_html):
+        banklist_data = datapath("io", "data", "html", "banklist.html")
+
+        flavor_read_html(banklist_data, match=".*Water.*", flavor=["lxml", "html5lib"])
+
+    def test_to_html_timestamp(self):
+        rng = date_range("2000-01-01", periods=10)
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)), index=rng)
+
+        result = df.to_html()
+        assert "2000-01-01" in result
+
+    def test_to_html_borderless(self):
+        df = DataFrame([{"A": 1, "B": 2}])
+        out_border_default = df.to_html()
+        out_border_true = df.to_html(border=True)
+        out_border_explicit_default = df.to_html(border=1)
+        out_border_nondefault = df.to_html(border=2)
+        out_border_zero = df.to_html(border=0)
+
+        out_border_false = df.to_html(border=False)
+
+        assert ' border="1"' in out_border_default
+        assert out_border_true == out_border_default
+        assert out_border_default == out_border_explicit_default
+        assert out_border_default != out_border_nondefault
+        assert ' border="2"' in out_border_nondefault
+        assert ' border="0"' not in out_border_zero
+        assert " border" not in out_border_false
+        assert out_border_zero == out_border_false
+
+    @pytest.mark.parametrize(
+        "displayed_only,exp0,exp1",
+        [
+            (True, DataFrame(["foo"]), None),
+            (False, DataFrame(["foo  bar  baz  qux"]), DataFrame(["foo"])),
+        ],
+    )
+    def test_displayed_only(self, displayed_only, exp0, exp1, flavor_read_html):
+        # GH 20027
+        data = """<html>
+          <body>
+            <table>
+              <tr>
+                <td>
+                  foo
+                  <span style="display:none;text-align:center">bar</span>
+                  <span style="display:none">baz</span>
+                  <span style="display: none">qux</span>
+                </td>
+              </tr>
+            </table>
+            <table style="display: none">
+              <tr>
+                <td>foo</td>
+              </tr>
+            </table>
+          </body>
+        </html>"""
+
+        dfs = flavor_read_html(StringIO(data), displayed_only=displayed_only)
+        tm.assert_frame_equal(dfs[0], exp0)
+
+        if exp1 is not None:
+            tm.assert_frame_equal(dfs[1], exp1)
+        else:
+            assert len(dfs) == 1  # Should not parse hidden table
+
+    @pytest.mark.parametrize("displayed_only", [True, False])
+    def test_displayed_only_with_many_elements(self, displayed_only, flavor_read_html):
+        html_table = """
+        <table>
+            <tr>
+                <th>A</th>
+                <th>B</th>
+            </tr>
+            <tr>
+                <td>1</td>
+                <td>2</td>
+            </tr>
+            <tr>
+                <td><span style="display:none"></span>4</td>
+                <td>5</td>
+            </tr>
+        </table>
+        """
+        result = flavor_read_html(StringIO(html_table), displayed_only=displayed_only)[
+            0
+        ]
+        expected = DataFrame({"A": [1, 4], "B": [2, 5]})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.filterwarnings(
+        "ignore:You provided Unicode markup but also provided a value for "
+        "from_encoding.*:UserWarning"
+    )
+    def test_encode(self, html_encoding_file, flavor_read_html):
+        base_path = os.path.basename(html_encoding_file)
+        root = os.path.splitext(base_path)[0]
+        _, encoding = root.split("_")
+
+        try:
+            with open(html_encoding_file, "rb") as fobj:
+                from_string = flavor_read_html(
+                    fobj.read(), encoding=encoding, index_col=0
+                ).pop()
+
+            with open(html_encoding_file, "rb") as fobj:
+                from_file_like = flavor_read_html(
+                    BytesIO(fobj.read()), encoding=encoding, index_col=0
+                ).pop()
+
+            from_filename = flavor_read_html(
+                html_encoding_file, encoding=encoding, index_col=0
+            ).pop()
+            tm.assert_frame_equal(from_string, from_file_like)
+            tm.assert_frame_equal(from_string, from_filename)
+        except Exception:
+            # seems utf-16/32 fail on windows
+            if is_platform_windows():
+                if "16" in encoding or "32" in encoding:
+                    pytest.skip()
+            raise
+
+    def test_parse_failure_unseekable(self, flavor_read_html):
+        # Issue #17975
+
+        if flavor_read_html.keywords.get("flavor") == "lxml":
+            pytest.skip("Not applicable for lxml")
+
+        class UnseekableStringIO(StringIO):
+            def seekable(self):
+                return False
+
+        bad = UnseekableStringIO(
+            """
+            <table><tr><td>spam<foobr />eggs</td></tr></table>"""
+        )
+
+        assert flavor_read_html(bad)
+
+        with pytest.raises(ValueError, match="passed a non-rewindable file object"):
+            flavor_read_html(bad)
+
+    def test_parse_failure_rewinds(self, flavor_read_html):
+        # Issue #17975
+
+        class MockFile:
+            def __init__(self, data) -> None:
+                self.data = data
+                self.at_end = False
+
+            def read(self, size=None):
+                data = "" if self.at_end else self.data
+                self.at_end = True
+                return data
+
+            def seek(self, offset):
+                self.at_end = False
+
+            def seekable(self):
+                return True
+
+            # GH 49036 pylint checks for presence of __next__ for iterators
+            def __next__(self):
+                ...
+
+            def __iter__(self) -> Iterator:
+                # `is_file_like` depends on the presence of
+                # the __iter__ attribute.
+                return self
+
+        good = MockFile("<table><tr><td>spam<br />eggs</td></tr></table>")
+        bad = MockFile("<table><tr><td>spam<foobr />eggs</td></tr></table>")
+
+        assert flavor_read_html(good)
+        assert flavor_read_html(bad)
+
+    @pytest.mark.slow
+    @pytest.mark.single_cpu
+    def test_importcheck_thread_safety(self, datapath, flavor_read_html):
+        # see gh-16928
+
+        class ErrorThread(threading.Thread):
+            def run(self):
+                try:
+                    super().run()
+                except Exception as err:
+                    self.err = err
+                else:
+                    self.err = None
+
+        filename = datapath("io", "data", "html", "valid_markup.html")
+        helper_thread1 = ErrorThread(target=flavor_read_html, args=(filename,))
+        helper_thread2 = ErrorThread(target=flavor_read_html, args=(filename,))
+
+        helper_thread1.start()
+        helper_thread2.start()
+
+        while helper_thread1.is_alive() or helper_thread2.is_alive():
+            pass
+        assert None is helper_thread1.err is helper_thread2.err
+
+    def test_parse_path_object(self, datapath, flavor_read_html):
+        # GH 37705
+        file_path_string = datapath("io", "data", "html", "spam.html")
+        file_path = Path(file_path_string)
+        df1 = flavor_read_html(file_path_string)[0]
+        df2 = flavor_read_html(file_path)[0]
+        tm.assert_frame_equal(df1, df2)
+
+    def test_parse_br_as_space(self, flavor_read_html):
+        # GH 29528: pd.read_html() convert <br> to space
+        result = flavor_read_html(
+            StringIO(
+                """
+            <table>
+                <tr>
+                    <th>A</th>
+                </tr>
+                <tr>
+                    <td>word1<br>word2</td>
+                </tr>
+            </table>
+        """
+            )
+        )[0]
+
+        expected = DataFrame(data=[["word1 word2"]], columns=["A"])
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("arg", ["all", "body", "header", "footer"])
+    def test_extract_links(self, arg, flavor_read_html):
+        gh_13141_data = """
+          <table>
+            <tr>
+              <th>HTTP</th>
+              <th>FTP</th>
+              <th><a href="https://en.wiktionary.org/wiki/linkless">Linkless</a></th>
+            </tr>
+            <tr>
+              <td><a href="https://en.wikipedia.org/">Wikipedia</a></td>
+              <td>SURROUNDING <a href="ftp://ftp.us.debian.org/">Debian</a> TEXT</td>
+              <td>Linkless</td>
+            </tr>
+            <tfoot>
+              <tr>
+                <td><a href="https://en.wikipedia.org/wiki/Page_footer">Footer</a></td>
+                <td>
+                  Multiple <a href="1">links:</a> <a href="2">Only first captured.</a>
+                </td>
+              </tr>
+            </tfoot>
+          </table>
+          """
+
+        gh_13141_expected = {
+            "head_ignore": ["HTTP", "FTP", "Linkless"],
+            "head_extract": [
+                ("HTTP", None),
+                ("FTP", None),
+                ("Linkless", "https://en.wiktionary.org/wiki/linkless"),
+            ],
+            "body_ignore": ["Wikipedia", "SURROUNDING Debian TEXT", "Linkless"],
+            "body_extract": [
+                ("Wikipedia", "https://en.wikipedia.org/"),
+                ("SURROUNDING Debian TEXT", "ftp://ftp.us.debian.org/"),
+                ("Linkless", None),
+            ],
+            "footer_ignore": [
+                "Footer",
+                "Multiple links: Only first captured.",
+                None,
+            ],
+            "footer_extract": [
+                ("Footer", "https://en.wikipedia.org/wiki/Page_footer"),
+                ("Multiple links: Only first captured.", "1"),
+                None,
+            ],
+        }
+
+        data_exp = gh_13141_expected["body_ignore"]
+        foot_exp = gh_13141_expected["footer_ignore"]
+        head_exp = gh_13141_expected["head_ignore"]
+        if arg == "all":
+            data_exp = gh_13141_expected["body_extract"]
+            foot_exp = gh_13141_expected["footer_extract"]
+            head_exp = gh_13141_expected["head_extract"]
+        elif arg == "body":
+            data_exp = gh_13141_expected["body_extract"]
+        elif arg == "footer":
+            foot_exp = gh_13141_expected["footer_extract"]
+        elif arg == "header":
+            head_exp = gh_13141_expected["head_extract"]
+
+        result = flavor_read_html(StringIO(gh_13141_data), extract_links=arg)[0]
+        expected = DataFrame([data_exp, foot_exp], columns=head_exp)
+        expected = expected.fillna(np.nan)
+        tm.assert_frame_equal(result, expected)
+
+    def test_extract_links_bad(self, spam_data):
+        msg = (
+            "`extract_links` must be one of "
+            '{None, "header", "footer", "body", "all"}, got "incorrect"'
+        )
+        with pytest.raises(ValueError, match=msg):
+            read_html(spam_data, extract_links="incorrect")
+
+    def test_extract_links_all_no_header(self, flavor_read_html):
+        # GH 48316
+        data = """
+        <table>
+          <tr>
+            <td>
+              <a href='https://google.com'>Google.com</a>
+            </td>
+          </tr>
+        </table>
+        """
+        result = flavor_read_html(StringIO(data), extract_links="all")[0]
+        expected = DataFrame([[("Google.com", "https://google.com")]])
+        tm.assert_frame_equal(result, expected)
+
+    def test_invalid_dtype_backend(self):
+        msg = (
+            "dtype_backend numpy is invalid, only 'numpy_nullable' and "
+            "'pyarrow' are allowed."
+        )
+        with pytest.raises(ValueError, match=msg):
+            read_html("test", dtype_backend="numpy")
+
+    def test_style_tag(self, flavor_read_html):
+        # GH 48316
+        data = """
+        <table>
+            <tr>
+                <th>
+                    <style>.style</style>
+                    A
+                    </th>
+                <th>B</th>
+            </tr>
+            <tr>
+                <td>A1</td>
+                <td>B1</td>
+            </tr>
+            <tr>
+                <td>A2</td>
+                <td>B2</td>
+            </tr>
+        </table>
+        """
+        result = flavor_read_html(StringIO(data))[0]
+        expected = DataFrame(data=[["A1", "B1"], ["A2", "B2"]], columns=["A", "B"])
+        tm.assert_frame_equal(result, expected)

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

@@ -0,0 +1,172 @@
+"""
+Tests for the pandas custom headers in http(s) requests
+"""
+from functools import partial
+import gzip
+from io import BytesIO
+
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+
+pytestmark = [
+    pytest.mark.single_cpu,
+    pytest.mark.network,
+    pytest.mark.filterwarnings(
+        "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+    ),
+]
+
+
+def gzip_bytes(response_bytes):
+    with BytesIO() as bio:
+        with gzip.GzipFile(fileobj=bio, mode="w") as zipper:
+            zipper.write(response_bytes)
+        return bio.getvalue()
+
+
+def csv_responder(df):
+    return df.to_csv(index=False).encode("utf-8")
+
+
+def gz_csv_responder(df):
+    return gzip_bytes(csv_responder(df))
+
+
+def json_responder(df):
+    return df.to_json().encode("utf-8")
+
+
+def gz_json_responder(df):
+    return gzip_bytes(json_responder(df))
+
+
+def html_responder(df):
+    return df.to_html(index=False).encode("utf-8")
+
+
+def parquetpyarrow_reponder(df):
+    return df.to_parquet(index=False, engine="pyarrow")
+
+
+def parquetfastparquet_responder(df):
+    # the fastparquet engine doesn't like to write to a buffer
+    # it can do it via the open_with function being set appropriately
+    # however it automatically calls the close method and wipes the buffer
+    # so just overwrite that attribute on this instance to not do that
+
+    # protected by an importorskip in the respective test
+    import fsspec
+
+    df.to_parquet(
+        "memory://fastparquet_user_agent.parquet",
+        index=False,
+        engine="fastparquet",
+        compression=None,
+    )
+    with fsspec.open("memory://fastparquet_user_agent.parquet", "rb") as f:
+        return f.read()
+
+
+def pickle_respnder(df):
+    with BytesIO() as bio:
+        df.to_pickle(bio)
+        return bio.getvalue()
+
+
+def stata_responder(df):
+    with BytesIO() as bio:
+        df.to_stata(bio, write_index=False)
+        return bio.getvalue()
+
+
+@pytest.mark.parametrize(
+    "responder, read_method",
+    [
+        (csv_responder, pd.read_csv),
+        (json_responder, pd.read_json),
+        (
+            html_responder,
+            lambda *args, **kwargs: pd.read_html(*args, **kwargs)[0],
+        ),
+        pytest.param(
+            parquetpyarrow_reponder,
+            partial(pd.read_parquet, engine="pyarrow"),
+            marks=td.skip_if_no("pyarrow"),
+        ),
+        pytest.param(
+            parquetfastparquet_responder,
+            partial(pd.read_parquet, engine="fastparquet"),
+            # TODO(ArrayManager) fastparquet
+            marks=[
+                td.skip_if_no("fastparquet"),
+                td.skip_if_no("fsspec"),
+                td.skip_array_manager_not_yet_implemented,
+            ],
+        ),
+        (pickle_respnder, pd.read_pickle),
+        (stata_responder, pd.read_stata),
+        (gz_csv_responder, pd.read_csv),
+        (gz_json_responder, pd.read_json),
+    ],
+)
+@pytest.mark.parametrize(
+    "storage_options",
+    [
+        None,
+        {"User-Agent": "foo"},
+        {"User-Agent": "foo", "Auth": "bar"},
+    ],
+)
+def test_request_headers(responder, read_method, httpserver, storage_options):
+    expected = pd.DataFrame({"a": ["b"]})
+    default_headers = ["Accept-Encoding", "Host", "Connection", "User-Agent"]
+    if "gz" in responder.__name__:
+        extra = {"Content-Encoding": "gzip"}
+        if storage_options is None:
+            storage_options = extra
+        else:
+            storage_options |= extra
+    else:
+        extra = None
+    expected_headers = set(default_headers).union(
+        storage_options.keys() if storage_options else []
+    )
+    httpserver.serve_content(content=responder(expected), headers=extra)
+    result = read_method(httpserver.url, storage_options=storage_options)
+    tm.assert_frame_equal(result, expected)
+
+    request_headers = dict(httpserver.requests[0].headers)
+    for header in expected_headers:
+        exp = request_headers.pop(header)
+        if storage_options and header in storage_options:
+            assert exp == storage_options[header]
+    # No extra headers added
+    assert not request_headers
+
+
+@pytest.mark.parametrize(
+    "engine",
+    [
+        "pyarrow",
+        "fastparquet",
+    ],
+)
+def test_to_parquet_to_disk_with_storage_options(engine):
+    headers = {
+        "User-Agent": "custom",
+        "Auth": "other_custom",
+    }
+
+    pytest.importorskip(engine)
+
+    true_df = pd.DataFrame({"column_name": ["column_value"]})
+    msg = (
+        "storage_options passed with file object or non-fsspec file path|"
+        "storage_options passed with buffer, or non-supported URL"
+    )
+    with pytest.raises(ValueError, match=msg):
+        true_df.to_parquet("/tmp/junk.parquet", storage_options=headers, engine=engine)

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

@@ -0,0 +1,436 @@
+""" test orc compat """
+import datetime
+from decimal import Decimal
+from io import BytesIO
+import os
+import pathlib
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import read_orc
+import pandas._testing as tm
+from pandas.core.arrays import StringArray
+
+pytest.importorskip("pyarrow.orc")
+
+import pyarrow as pa
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+@pytest.fixture
+def dirpath(datapath):
+    return datapath("io", "data", "orc")
+
+
+@pytest.fixture(
+    params=[
+        np.array([1, 20], dtype="uint64"),
+        pd.Series(["a", "b", "a"], dtype="category"),
+        [pd.Interval(left=0, right=2), pd.Interval(left=0, right=5)],
+        [pd.Period("2022-01-03", freq="D"), pd.Period("2022-01-04", freq="D")],
+    ]
+)
+def orc_writer_dtypes_not_supported(request):
+    # Examples of dataframes with dtypes for which conversion to ORC
+    # hasn't been implemented yet, that is, Category, unsigned integers,
+    # interval, period and sparse.
+    return pd.DataFrame({"unimpl": request.param})
+
+
+def test_orc_reader_empty(dirpath):
+    columns = [
+        "boolean1",
+        "byte1",
+        "short1",
+        "int1",
+        "long1",
+        "float1",
+        "double1",
+        "bytes1",
+        "string1",
+    ]
+    dtypes = [
+        "bool",
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "float32",
+        "float64",
+        "object",
+        "object",
+    ]
+    expected = pd.DataFrame(index=pd.RangeIndex(0))
+    for colname, dtype in zip(columns, dtypes):
+        expected[colname] = pd.Series(dtype=dtype)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.emptyFile.orc")
+    got = read_orc(inputfile, columns=columns)
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_basic(dirpath):
+    data = {
+        "boolean1": np.array([False, True], dtype="bool"),
+        "byte1": np.array([1, 100], dtype="int8"),
+        "short1": np.array([1024, 2048], dtype="int16"),
+        "int1": np.array([65536, 65536], dtype="int32"),
+        "long1": np.array([9223372036854775807, 9223372036854775807], dtype="int64"),
+        "float1": np.array([1.0, 2.0], dtype="float32"),
+        "double1": np.array([-15.0, -5.0], dtype="float64"),
+        "bytes1": np.array([b"\x00\x01\x02\x03\x04", b""], dtype="object"),
+        "string1": np.array(["hi", "bye"], dtype="object"),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.test1.orc")
+    got = read_orc(inputfile, columns=data.keys())
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_decimal(dirpath):
+    # Only testing the first 10 rows of data
+    data = {
+        "_col0": np.array(
+            [
+                Decimal("-1000.50000"),
+                Decimal("-999.60000"),
+                Decimal("-998.70000"),
+                Decimal("-997.80000"),
+                Decimal("-996.90000"),
+                Decimal("-995.10000"),
+                Decimal("-994.11000"),
+                Decimal("-993.12000"),
+                Decimal("-992.13000"),
+                Decimal("-991.14000"),
+            ],
+            dtype="object",
+        )
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.decimal.orc")
+    got = read_orc(inputfile).iloc[:10]
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_date_low(dirpath):
+    data = {
+        "time": np.array(
+            [
+                "1900-05-05 12:34:56.100000",
+                "1900-05-05 12:34:56.100100",
+                "1900-05-05 12:34:56.100200",
+                "1900-05-05 12:34:56.100300",
+                "1900-05-05 12:34:56.100400",
+                "1900-05-05 12:34:56.100500",
+                "1900-05-05 12:34:56.100600",
+                "1900-05-05 12:34:56.100700",
+                "1900-05-05 12:34:56.100800",
+                "1900-05-05 12:34:56.100900",
+            ],
+            dtype="datetime64[ns]",
+        ),
+        "date": np.array(
+            [
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+                datetime.date(1900, 12, 25),
+            ],
+            dtype="object",
+        ),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.testDate1900.orc")
+    got = read_orc(inputfile).iloc[:10]
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_date_high(dirpath):
+    data = {
+        "time": np.array(
+            [
+                "2038-05-05 12:34:56.100000",
+                "2038-05-05 12:34:56.100100",
+                "2038-05-05 12:34:56.100200",
+                "2038-05-05 12:34:56.100300",
+                "2038-05-05 12:34:56.100400",
+                "2038-05-05 12:34:56.100500",
+                "2038-05-05 12:34:56.100600",
+                "2038-05-05 12:34:56.100700",
+                "2038-05-05 12:34:56.100800",
+                "2038-05-05 12:34:56.100900",
+            ],
+            dtype="datetime64[ns]",
+        ),
+        "date": np.array(
+            [
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+                datetime.date(2038, 12, 25),
+            ],
+            dtype="object",
+        ),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.testDate2038.orc")
+    got = read_orc(inputfile).iloc[:10]
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_reader_snappy_compressed(dirpath):
+    data = {
+        "int1": np.array(
+            [
+                -1160101563,
+                1181413113,
+                2065821249,
+                -267157795,
+                172111193,
+                1752363137,
+                1406072123,
+                1911809390,
+                -1308542224,
+                -467100286,
+            ],
+            dtype="int32",
+        ),
+        "string1": np.array(
+            [
+                "f50dcb8",
+                "382fdaaa",
+                "90758c6",
+                "9e8caf3f",
+                "ee97332b",
+                "d634da1",
+                "2bea4396",
+                "d67d89e8",
+                "ad71007e",
+                "e8c82066",
+            ],
+            dtype="object",
+        ),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    inputfile = os.path.join(dirpath, "TestOrcFile.testSnappy.orc")
+    got = read_orc(inputfile).iloc[:10]
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_roundtrip_file(dirpath):
+    # GH44554
+    # PyArrow gained ORC write support with the current argument order
+    pytest.importorskip("pyarrow")
+
+    data = {
+        "boolean1": np.array([False, True], dtype="bool"),
+        "byte1": np.array([1, 100], dtype="int8"),
+        "short1": np.array([1024, 2048], dtype="int16"),
+        "int1": np.array([65536, 65536], dtype="int32"),
+        "long1": np.array([9223372036854775807, 9223372036854775807], dtype="int64"),
+        "float1": np.array([1.0, 2.0], dtype="float32"),
+        "double1": np.array([-15.0, -5.0], dtype="float64"),
+        "bytes1": np.array([b"\x00\x01\x02\x03\x04", b""], dtype="object"),
+        "string1": np.array(["hi", "bye"], dtype="object"),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    with tm.ensure_clean() as path:
+        expected.to_orc(path)
+        got = read_orc(path)
+
+        tm.assert_equal(expected, got)
+
+
+def test_orc_roundtrip_bytesio():
+    # GH44554
+    # PyArrow gained ORC write support with the current argument order
+    pytest.importorskip("pyarrow")
+
+    data = {
+        "boolean1": np.array([False, True], dtype="bool"),
+        "byte1": np.array([1, 100], dtype="int8"),
+        "short1": np.array([1024, 2048], dtype="int16"),
+        "int1": np.array([65536, 65536], dtype="int32"),
+        "long1": np.array([9223372036854775807, 9223372036854775807], dtype="int64"),
+        "float1": np.array([1.0, 2.0], dtype="float32"),
+        "double1": np.array([-15.0, -5.0], dtype="float64"),
+        "bytes1": np.array([b"\x00\x01\x02\x03\x04", b""], dtype="object"),
+        "string1": np.array(["hi", "bye"], dtype="object"),
+    }
+    expected = pd.DataFrame.from_dict(data)
+
+    bytes = expected.to_orc()
+    got = read_orc(BytesIO(bytes))
+
+    tm.assert_equal(expected, got)
+
+
+def test_orc_writer_dtypes_not_supported(orc_writer_dtypes_not_supported):
+    # GH44554
+    # PyArrow gained ORC write support with the current argument order
+    pytest.importorskip("pyarrow")
+
+    msg = "The dtype of one or more columns is not supported yet."
+    with pytest.raises(NotImplementedError, match=msg):
+        orc_writer_dtypes_not_supported.to_orc()
+
+
+def test_orc_dtype_backend_pyarrow():
+    pytest.importorskip("pyarrow")
+    df = pd.DataFrame(
+        {
+            "string": list("abc"),
+            "string_with_nan": ["a", np.nan, "c"],
+            "string_with_none": ["a", None, "c"],
+            "bytes": [b"foo", b"bar", None],
+            "int": list(range(1, 4)),
+            "float": np.arange(4.0, 7.0, dtype="float64"),
+            "float_with_nan": [2.0, np.nan, 3.0],
+            "bool": [True, False, True],
+            "bool_with_na": [True, False, None],
+            "datetime": pd.date_range("20130101", periods=3),
+            "datetime_with_nat": [
+                pd.Timestamp("20130101"),
+                pd.NaT,
+                pd.Timestamp("20130103"),
+            ],
+        }
+    )
+
+    bytes_data = df.copy().to_orc()
+    result = read_orc(BytesIO(bytes_data), dtype_backend="pyarrow")
+
+    expected = pd.DataFrame(
+        {
+            col: pd.arrays.ArrowExtensionArray(pa.array(df[col], from_pandas=True))
+            for col in df.columns
+        }
+    )
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_orc_dtype_backend_numpy_nullable():
+    # GH#50503
+    pytest.importorskip("pyarrow")
+    df = pd.DataFrame(
+        {
+            "string": list("abc"),
+            "string_with_nan": ["a", np.nan, "c"],
+            "string_with_none": ["a", None, "c"],
+            "int": list(range(1, 4)),
+            "int_with_nan": pd.Series([1, pd.NA, 3], dtype="Int64"),
+            "na_only": pd.Series([pd.NA, pd.NA, pd.NA], dtype="Int64"),
+            "float": np.arange(4.0, 7.0, dtype="float64"),
+            "float_with_nan": [2.0, np.nan, 3.0],
+            "bool": [True, False, True],
+            "bool_with_na": [True, False, None],
+        }
+    )
+
+    bytes_data = df.copy().to_orc()
+    result = read_orc(BytesIO(bytes_data), dtype_backend="numpy_nullable")
+
+    expected = pd.DataFrame(
+        {
+            "string": StringArray(np.array(["a", "b", "c"], dtype=np.object_)),
+            "string_with_nan": StringArray(
+                np.array(["a", pd.NA, "c"], dtype=np.object_)
+            ),
+            "string_with_none": StringArray(
+                np.array(["a", pd.NA, "c"], dtype=np.object_)
+            ),
+            "int": pd.Series([1, 2, 3], dtype="Int64"),
+            "int_with_nan": pd.Series([1, pd.NA, 3], dtype="Int64"),
+            "na_only": pd.Series([pd.NA, pd.NA, pd.NA], dtype="Int64"),
+            "float": pd.Series([4.0, 5.0, 6.0], dtype="Float64"),
+            "float_with_nan": pd.Series([2.0, pd.NA, 3.0], dtype="Float64"),
+            "bool": pd.Series([True, False, True], dtype="boolean"),
+            "bool_with_na": pd.Series([True, False, pd.NA], dtype="boolean"),
+        }
+    )
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_orc_uri_path():
+    expected = pd.DataFrame({"int": list(range(1, 4))})
+    with tm.ensure_clean("tmp.orc") as path:
+        expected.to_orc(path)
+        uri = pathlib.Path(path).as_uri()
+        result = read_orc(uri)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "index",
+    [
+        pd.RangeIndex(start=2, stop=5, step=1),
+        pd.RangeIndex(start=0, stop=3, step=1, name="non-default"),
+        pd.Index([1, 2, 3]),
+    ],
+)
+def test_to_orc_non_default_index(index):
+    df = pd.DataFrame({"a": [1, 2, 3]}, index=index)
+    msg = (
+        "orc does not support serializing a non-default index|"
+        "orc does not serialize index meta-data"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.to_orc()
+
+
+def test_invalid_dtype_backend():
+    msg = (
+        "dtype_backend numpy is invalid, only 'numpy_nullable' and "
+        "'pyarrow' are allowed."
+    )
+    df = pd.DataFrame({"int": list(range(1, 4))})
+    with tm.ensure_clean("tmp.orc") as path:
+        df.to_orc(path)
+        with pytest.raises(ValueError, match=msg):
+            read_orc(path, dtype_backend="numpy")
+
+
+def test_string_inference(tmp_path):
+    # GH#54431
+    path = tmp_path / "test_string_inference.p"
+    df = pd.DataFrame(data={"a": ["x", "y"]})
+    df.to_orc(path)
+    with pd.option_context("future.infer_string", True):
+        result = read_orc(path)
+    expected = pd.DataFrame(
+        data={"a": ["x", "y"]},
+        dtype="string[pyarrow_numpy]",
+        columns=pd.Index(["a"], dtype="string[pyarrow_numpy]"),
+    )
+    tm.assert_frame_equal(result, expected)

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

@@ -0,0 +1,1424 @@
+""" test parquet compat """
+import datetime
+from decimal import Decimal
+from io import BytesIO
+import os
+import pathlib
+
+import numpy as np
+import pytest
+
+from pandas._config import using_copy_on_write
+from pandas._config.config import _get_option
+
+from pandas.compat import is_platform_windows
+from pandas.compat.pyarrow import (
+    pa_version_under11p0,
+    pa_version_under13p0,
+    pa_version_under15p0,
+)
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.util.version import Version
+
+from pandas.io.parquet import (
+    FastParquetImpl,
+    PyArrowImpl,
+    get_engine,
+    read_parquet,
+    to_parquet,
+)
+
+try:
+    import pyarrow
+
+    _HAVE_PYARROW = True
+except ImportError:
+    _HAVE_PYARROW = False
+
+try:
+    import fastparquet
+
+    _HAVE_FASTPARQUET = True
+except ImportError:
+    _HAVE_FASTPARQUET = False
+
+
+# TODO(ArrayManager) fastparquet relies on BlockManager internals
+
+pytestmark = [
+    pytest.mark.filterwarnings("ignore:DataFrame._data is deprecated:FutureWarning"),
+    pytest.mark.filterwarnings(
+        "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+    ),
+]
+
+
+# setup engines & skips
+@pytest.fixture(
+    params=[
+        pytest.param(
+            "fastparquet",
+            marks=pytest.mark.skipif(
+                not _HAVE_FASTPARQUET
+                or _get_option("mode.data_manager", silent=True) == "array",
+                reason="fastparquet is not installed or ArrayManager is used",
+            ),
+        ),
+        pytest.param(
+            "pyarrow",
+            marks=pytest.mark.skipif(
+                not _HAVE_PYARROW, reason="pyarrow is not installed"
+            ),
+        ),
+    ]
+)
+def engine(request):
+    return request.param
+
+
+@pytest.fixture
+def pa():
+    if not _HAVE_PYARROW:
+        pytest.skip("pyarrow is not installed")
+    return "pyarrow"
+
+
+@pytest.fixture
+def fp():
+    if not _HAVE_FASTPARQUET:
+        pytest.skip("fastparquet is not installed")
+    elif _get_option("mode.data_manager", silent=True) == "array":
+        pytest.skip("ArrayManager is not supported with fastparquet")
+    return "fastparquet"
+
+
+@pytest.fixture
+def df_compat():
+    return pd.DataFrame({"A": [1, 2, 3], "B": "foo"})
+
+
+@pytest.fixture
+def df_cross_compat():
+    df = pd.DataFrame(
+        {
+            "a": list("abc"),
+            "b": list(range(1, 4)),
+            # 'c': np.arange(3, 6).astype('u1'),
+            "d": np.arange(4.0, 7.0, dtype="float64"),
+            "e": [True, False, True],
+            "f": pd.date_range("20130101", periods=3),
+            # 'g': pd.date_range('20130101', periods=3,
+            #                    tz='US/Eastern'),
+            # 'h': pd.date_range('20130101', periods=3, freq='ns')
+        }
+    )
+    return df
+
+
+@pytest.fixture
+def df_full():
+    return pd.DataFrame(
+        {
+            "string": list("abc"),
+            "string_with_nan": ["a", np.nan, "c"],
+            "string_with_none": ["a", None, "c"],
+            "bytes": [b"foo", b"bar", b"baz"],
+            "unicode": ["foo", "bar", "baz"],
+            "int": list(range(1, 4)),
+            "uint": np.arange(3, 6).astype("u1"),
+            "float": np.arange(4.0, 7.0, dtype="float64"),
+            "float_with_nan": [2.0, np.nan, 3.0],
+            "bool": [True, False, True],
+            "datetime": pd.date_range("20130101", periods=3),
+            "datetime_with_nat": [
+                pd.Timestamp("20130101"),
+                pd.NaT,
+                pd.Timestamp("20130103"),
+            ],
+        }
+    )
+
+
+@pytest.fixture(
+    params=[
+        datetime.datetime.now(datetime.timezone.utc),
+        datetime.datetime.now(datetime.timezone.min),
+        datetime.datetime.now(datetime.timezone.max),
+        datetime.datetime.strptime("2019-01-04T16:41:24+0200", "%Y-%m-%dT%H:%M:%S%z"),
+        datetime.datetime.strptime("2019-01-04T16:41:24+0215", "%Y-%m-%dT%H:%M:%S%z"),
+        datetime.datetime.strptime("2019-01-04T16:41:24-0200", "%Y-%m-%dT%H:%M:%S%z"),
+        datetime.datetime.strptime("2019-01-04T16:41:24-0215", "%Y-%m-%dT%H:%M:%S%z"),
+    ]
+)
+def timezone_aware_date_list(request):
+    return request.param
+
+
+def check_round_trip(
+    df,
+    engine=None,
+    path=None,
+    write_kwargs=None,
+    read_kwargs=None,
+    expected=None,
+    check_names=True,
+    check_like=False,
+    check_dtype=True,
+    repeat=2,
+):
+    """Verify parquet serializer and deserializer produce the same results.
+
+    Performs a pandas to disk and disk to pandas round trip,
+    then compares the 2 resulting DataFrames to verify equality.
+
+    Parameters
+    ----------
+    df: Dataframe
+    engine: str, optional
+        'pyarrow' or 'fastparquet'
+    path: str, optional
+    write_kwargs: dict of str:str, optional
+    read_kwargs: dict of str:str, optional
+    expected: DataFrame, optional
+        Expected deserialization result, otherwise will be equal to `df`
+    check_names: list of str, optional
+        Closed set of column names to be compared
+    check_like: bool, optional
+        If True, ignore the order of index & columns.
+    repeat: int, optional
+        How many times to repeat the test
+    """
+    write_kwargs = write_kwargs or {"compression": None}
+    read_kwargs = read_kwargs or {}
+
+    if expected is None:
+        expected = df
+
+    if engine:
+        write_kwargs["engine"] = engine
+        read_kwargs["engine"] = engine
+
+    def compare(repeat):
+        for _ in range(repeat):
+            df.to_parquet(path, **write_kwargs)
+            actual = read_parquet(path, **read_kwargs)
+
+            if "string_with_nan" in expected:
+                expected.loc[1, "string_with_nan"] = None
+            tm.assert_frame_equal(
+                expected,
+                actual,
+                check_names=check_names,
+                check_like=check_like,
+                check_dtype=check_dtype,
+            )
+
+    if path is None:
+        with tm.ensure_clean() as path:
+            compare(repeat)
+    else:
+        compare(repeat)
+
+
+def check_partition_names(path, expected):
+    """Check partitions of a parquet file are as expected.
+
+    Parameters
+    ----------
+    path: str
+        Path of the dataset.
+    expected: iterable of str
+        Expected partition names.
+    """
+    import pyarrow.dataset as ds
+
+    dataset = ds.dataset(path, partitioning="hive")
+    assert dataset.partitioning.schema.names == expected
+
+
+def test_invalid_engine(df_compat):
+    msg = "engine must be one of 'pyarrow', 'fastparquet'"
+    with pytest.raises(ValueError, match=msg):
+        check_round_trip(df_compat, "foo", "bar")
+
+
+def test_options_py(df_compat, pa):
+    # use the set option
+
+    with pd.option_context("io.parquet.engine", "pyarrow"):
+        check_round_trip(df_compat)
+
+
+def test_options_fp(df_compat, fp):
+    # use the set option
+
+    with pd.option_context("io.parquet.engine", "fastparquet"):
+        check_round_trip(df_compat)
+
+
+def test_options_auto(df_compat, fp, pa):
+    # use the set option
+
+    with pd.option_context("io.parquet.engine", "auto"):
+        check_round_trip(df_compat)
+
+
+def test_options_get_engine(fp, pa):
+    assert isinstance(get_engine("pyarrow"), PyArrowImpl)
+    assert isinstance(get_engine("fastparquet"), FastParquetImpl)
+
+    with pd.option_context("io.parquet.engine", "pyarrow"):
+        assert isinstance(get_engine("auto"), PyArrowImpl)
+        assert isinstance(get_engine("pyarrow"), PyArrowImpl)
+        assert isinstance(get_engine("fastparquet"), FastParquetImpl)
+
+    with pd.option_context("io.parquet.engine", "fastparquet"):
+        assert isinstance(get_engine("auto"), FastParquetImpl)
+        assert isinstance(get_engine("pyarrow"), PyArrowImpl)
+        assert isinstance(get_engine("fastparquet"), FastParquetImpl)
+
+    with pd.option_context("io.parquet.engine", "auto"):
+        assert isinstance(get_engine("auto"), PyArrowImpl)
+        assert isinstance(get_engine("pyarrow"), PyArrowImpl)
+        assert isinstance(get_engine("fastparquet"), FastParquetImpl)
+
+
+def test_get_engine_auto_error_message():
+    # Expect different error messages from get_engine(engine="auto")
+    # if engines aren't installed vs. are installed but bad version
+    from pandas.compat._optional import VERSIONS
+
+    # Do we have engines installed, but a bad version of them?
+    pa_min_ver = VERSIONS.get("pyarrow")
+    fp_min_ver = VERSIONS.get("fastparquet")
+    have_pa_bad_version = (
+        False
+        if not _HAVE_PYARROW
+        else Version(pyarrow.__version__) < Version(pa_min_ver)
+    )
+    have_fp_bad_version = (
+        False
+        if not _HAVE_FASTPARQUET
+        else Version(fastparquet.__version__) < Version(fp_min_ver)
+    )
+    # Do we have usable engines installed?
+    have_usable_pa = _HAVE_PYARROW and not have_pa_bad_version
+    have_usable_fp = _HAVE_FASTPARQUET and not have_fp_bad_version
+
+    if not have_usable_pa and not have_usable_fp:
+        # No usable engines found.
+        if have_pa_bad_version:
+            match = f"Pandas requires version .{pa_min_ver}. or newer of .pyarrow."
+            with pytest.raises(ImportError, match=match):
+                get_engine("auto")
+        else:
+            match = "Missing optional dependency .pyarrow."
+            with pytest.raises(ImportError, match=match):
+                get_engine("auto")
+
+        if have_fp_bad_version:
+            match = f"Pandas requires version .{fp_min_ver}. or newer of .fastparquet."
+            with pytest.raises(ImportError, match=match):
+                get_engine("auto")
+        else:
+            match = "Missing optional dependency .fastparquet."
+            with pytest.raises(ImportError, match=match):
+                get_engine("auto")
+
+
+def test_cross_engine_pa_fp(df_cross_compat, pa, fp):
+    # cross-compat with differing reading/writing engines
+
+    df = df_cross_compat
+    with tm.ensure_clean() as path:
+        df.to_parquet(path, engine=pa, compression=None)
+
+        result = read_parquet(path, engine=fp)
+        tm.assert_frame_equal(result, df)
+
+        result = read_parquet(path, engine=fp, columns=["a", "d"])
+        tm.assert_frame_equal(result, df[["a", "d"]])
+
+
+def test_cross_engine_fp_pa(df_cross_compat, pa, fp):
+    # cross-compat with differing reading/writing engines
+    df = df_cross_compat
+    with tm.ensure_clean() as path:
+        df.to_parquet(path, engine=fp, compression=None)
+
+        result = read_parquet(path, engine=pa)
+        tm.assert_frame_equal(result, df)
+
+        result = read_parquet(path, engine=pa, columns=["a", "d"])
+        tm.assert_frame_equal(result, df[["a", "d"]])
+
+
+def test_parquet_pos_args_deprecation(engine):
+    # GH-54229
+    df = pd.DataFrame({"a": [1, 2, 3]})
+    msg = (
+        r"Starting with pandas version 3.0 all arguments of to_parquet except for the "
+        r"argument 'path' will be keyword-only."
+    )
+    with tm.ensure_clean() as path:
+        with tm.assert_produces_warning(
+            FutureWarning,
+            match=msg,
+            check_stacklevel=False,
+            raise_on_extra_warnings=False,
+        ):
+            df.to_parquet(path, engine)
+
+
+class Base:
+    def check_error_on_write(self, df, engine, exc, err_msg):
+        # check that we are raising the exception on writing
+        with tm.ensure_clean() as path:
+            with pytest.raises(exc, match=err_msg):
+                to_parquet(df, path, engine, compression=None)
+
+    def check_external_error_on_write(self, df, engine, exc):
+        # check that an external library is raising the exception on writing
+        with tm.ensure_clean() as path:
+            with tm.external_error_raised(exc):
+                to_parquet(df, path, engine, compression=None)
+
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    def test_parquet_read_from_url(self, httpserver, datapath, df_compat, engine):
+        if engine != "auto":
+            pytest.importorskip(engine)
+        with open(datapath("io", "data", "parquet", "simple.parquet"), mode="rb") as f:
+            httpserver.serve_content(content=f.read())
+            df = read_parquet(httpserver.url)
+        tm.assert_frame_equal(df, df_compat)
+
+
+class TestBasic(Base):
+    def test_error(self, engine):
+        for obj in [
+            pd.Series([1, 2, 3]),
+            1,
+            "foo",
+            pd.Timestamp("20130101"),
+            np.array([1, 2, 3]),
+        ]:
+            msg = "to_parquet only supports IO with DataFrames"
+            self.check_error_on_write(obj, engine, ValueError, msg)
+
+    def test_columns_dtypes(self, engine):
+        df = pd.DataFrame({"string": list("abc"), "int": list(range(1, 4))})
+
+        # unicode
+        df.columns = ["foo", "bar"]
+        check_round_trip(df, engine)
+
+    @pytest.mark.parametrize("compression", [None, "gzip", "snappy", "brotli"])
+    def test_compression(self, engine, compression):
+        df = pd.DataFrame({"A": [1, 2, 3]})
+        check_round_trip(df, engine, write_kwargs={"compression": compression})
+
+    def test_read_columns(self, engine):
+        # GH18154
+        df = pd.DataFrame({"string": list("abc"), "int": list(range(1, 4))})
+
+        expected = pd.DataFrame({"string": list("abc")})
+        check_round_trip(
+            df, engine, expected=expected, read_kwargs={"columns": ["string"]}
+        )
+
+    def test_read_filters(self, engine, tmp_path):
+        df = pd.DataFrame(
+            {
+                "int": list(range(4)),
+                "part": list("aabb"),
+            }
+        )
+
+        expected = pd.DataFrame({"int": [0, 1]})
+        check_round_trip(
+            df,
+            engine,
+            path=tmp_path,
+            expected=expected,
+            write_kwargs={"partition_cols": ["part"]},
+            read_kwargs={"filters": [("part", "==", "a")], "columns": ["int"]},
+            repeat=1,
+        )
+
+    def test_write_index(self, engine, using_copy_on_write, request):
+        check_names = engine != "fastparquet"
+        if using_copy_on_write and engine == "fastparquet":
+            request.applymarker(
+                pytest.mark.xfail(reason="fastparquet write into index")
+            )
+
+        df = pd.DataFrame({"A": [1, 2, 3]})
+        check_round_trip(df, engine)
+
+        indexes = [
+            [2, 3, 4],
+            pd.date_range("20130101", periods=3),
+            list("abc"),
+            [1, 3, 4],
+        ]
+        # non-default index
+        for index in indexes:
+            df.index = index
+            if isinstance(index, pd.DatetimeIndex):
+                df.index = df.index._with_freq(None)  # freq doesn't round-trip
+            check_round_trip(df, engine, check_names=check_names)
+
+        # index with meta-data
+        df.index = [0, 1, 2]
+        df.index.name = "foo"
+        check_round_trip(df, engine)
+
+    def test_write_multiindex(self, pa):
+        # Not supported in fastparquet as of 0.1.3 or older pyarrow version
+        engine = pa
+
+        df = pd.DataFrame({"A": [1, 2, 3]})
+        index = pd.MultiIndex.from_tuples([("a", 1), ("a", 2), ("b", 1)])
+        df.index = index
+        check_round_trip(df, engine)
+
+    def test_multiindex_with_columns(self, pa):
+        engine = pa
+        dates = pd.date_range("01-Jan-2018", "01-Dec-2018", freq="MS")
+        df = pd.DataFrame(
+            np.random.default_rng(2).standard_normal((2 * len(dates), 3)),
+            columns=list("ABC"),
+        )
+        index1 = pd.MultiIndex.from_product(
+            [["Level1", "Level2"], dates], names=["level", "date"]
+        )
+        index2 = index1.copy(names=None)
+        for index in [index1, index2]:
+            df.index = index
+
+            check_round_trip(df, engine)
+            check_round_trip(
+                df, engine, read_kwargs={"columns": ["A", "B"]}, expected=df[["A", "B"]]
+            )
+
+    def test_write_ignoring_index(self, engine):
+        # ENH 20768
+        # Ensure index=False omits the index from the written Parquet file.
+        df = pd.DataFrame({"a": [1, 2, 3], "b": ["q", "r", "s"]})
+
+        write_kwargs = {"compression": None, "index": False}
+
+        # Because we're dropping the index, we expect the loaded dataframe to
+        # have the default integer index.
+        expected = df.reset_index(drop=True)
+
+        check_round_trip(df, engine, write_kwargs=write_kwargs, expected=expected)
+
+        # Ignore custom index
+        df = pd.DataFrame(
+            {"a": [1, 2, 3], "b": ["q", "r", "s"]}, index=["zyx", "wvu", "tsr"]
+        )
+
+        check_round_trip(df, engine, write_kwargs=write_kwargs, expected=expected)
+
+        # Ignore multi-indexes as well.
+        arrays = [
+            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+            ["one", "two", "one", "two", "one", "two", "one", "two"],
+        ]
+        df = pd.DataFrame(
+            {"one": list(range(8)), "two": [-i for i in range(8)]}, index=arrays
+        )
+
+        expected = df.reset_index(drop=True)
+        check_round_trip(df, engine, write_kwargs=write_kwargs, expected=expected)
+
+    def test_write_column_multiindex(self, engine):
+        # Not able to write column multi-indexes with non-string column names.
+        mi_columns = pd.MultiIndex.from_tuples([("a", 1), ("a", 2), ("b", 1)])
+        df = pd.DataFrame(
+            np.random.default_rng(2).standard_normal((4, 3)), columns=mi_columns
+        )
+
+        if engine == "fastparquet":
+            self.check_error_on_write(
+                df, engine, TypeError, "Column name must be a string"
+            )
+        elif engine == "pyarrow":
+            check_round_trip(df, engine)
+
+    def test_write_column_multiindex_nonstring(self, engine):
+        # GH #34777
+
+        # Not able to write column multi-indexes with non-string column names
+        arrays = [
+            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+            [1, 2, 1, 2, 1, 2, 1, 2],
+        ]
+        df = pd.DataFrame(
+            np.random.default_rng(2).standard_normal((8, 8)), columns=arrays
+        )
+        df.columns.names = ["Level1", "Level2"]
+        if engine == "fastparquet":
+            self.check_error_on_write(df, engine, ValueError, "Column name")
+        elif engine == "pyarrow":
+            check_round_trip(df, engine)
+
+    def test_write_column_multiindex_string(self, pa):
+        # GH #34777
+        # Not supported in fastparquet as of 0.1.3
+        engine = pa
+
+        # Write column multi-indexes with string column names
+        arrays = [
+            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+            ["one", "two", "one", "two", "one", "two", "one", "two"],
+        ]
+        df = pd.DataFrame(
+            np.random.default_rng(2).standard_normal((8, 8)), columns=arrays
+        )
+        df.columns.names = ["ColLevel1", "ColLevel2"]
+
+        check_round_trip(df, engine)
+
+    def test_write_column_index_string(self, pa):
+        # GH #34777
+        # Not supported in fastparquet as of 0.1.3
+        engine = pa
+
+        # Write column indexes with string column names
+        arrays = ["bar", "baz", "foo", "qux"]
+        df = pd.DataFrame(
+            np.random.default_rng(2).standard_normal((8, 4)), columns=arrays
+        )
+        df.columns.name = "StringCol"
+
+        check_round_trip(df, engine)
+
+    def test_write_column_index_nonstring(self, engine):
+        # GH #34777
+
+        # Write column indexes with string column names
+        arrays = [1, 2, 3, 4]
+        df = pd.DataFrame(
+            np.random.default_rng(2).standard_normal((8, 4)), columns=arrays
+        )
+        df.columns.name = "NonStringCol"
+        if engine == "fastparquet":
+            self.check_error_on_write(
+                df, engine, TypeError, "Column name must be a string"
+            )
+        else:
+            check_round_trip(df, engine)
+
+    def test_dtype_backend(self, engine, request):
+        pq = pytest.importorskip("pyarrow.parquet")
+
+        if engine == "fastparquet":
+            # We are manually disabling fastparquet's
+            # nullable dtype support pending discussion
+            mark = pytest.mark.xfail(
+                reason="Fastparquet nullable dtype support is disabled"
+            )
+            request.applymarker(mark)
+
+        table = pyarrow.table(
+            {
+                "a": pyarrow.array([1, 2, 3, None], "int64"),
+                "b": pyarrow.array([1, 2, 3, None], "uint8"),
+                "c": pyarrow.array(["a", "b", "c", None]),
+                "d": pyarrow.array([True, False, True, None]),
+                # Test that nullable dtypes used even in absence of nulls
+                "e": pyarrow.array([1, 2, 3, 4], "int64"),
+                # GH 45694
+                "f": pyarrow.array([1.0, 2.0, 3.0, None], "float32"),
+                "g": pyarrow.array([1.0, 2.0, 3.0, None], "float64"),
+            }
+        )
+        with tm.ensure_clean() as path:
+            # write manually with pyarrow to write integers
+            pq.write_table(table, path)
+            result1 = read_parquet(path, engine=engine)
+            result2 = read_parquet(path, engine=engine, dtype_backend="numpy_nullable")
+
+        assert result1["a"].dtype == np.dtype("float64")
+        expected = pd.DataFrame(
+            {
+                "a": pd.array([1, 2, 3, None], dtype="Int64"),
+                "b": pd.array([1, 2, 3, None], dtype="UInt8"),
+                "c": pd.array(["a", "b", "c", None], dtype="string"),
+                "d": pd.array([True, False, True, None], dtype="boolean"),
+                "e": pd.array([1, 2, 3, 4], dtype="Int64"),
+                "f": pd.array([1.0, 2.0, 3.0, None], dtype="Float32"),
+                "g": pd.array([1.0, 2.0, 3.0, None], dtype="Float64"),
+            }
+        )
+        if engine == "fastparquet":
+            # Fastparquet doesn't support string columns yet
+            # Only int and boolean
+            result2 = result2.drop("c", axis=1)
+            expected = expected.drop("c", axis=1)
+        tm.assert_frame_equal(result2, expected)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "Int64",
+            "UInt8",
+            "boolean",
+            "object",
+            "datetime64[ns, UTC]",
+            "float",
+            "period[D]",
+            "Float64",
+            "string",
+        ],
+    )
+    def test_read_empty_array(self, pa, dtype):
+        # GH #41241
+        df = pd.DataFrame(
+            {
+                "value": pd.array([], dtype=dtype),
+            }
+        )
+        # GH 45694
+        expected = None
+        if dtype == "float":
+            expected = pd.DataFrame(
+                {
+                    "value": pd.array([], dtype="Float64"),
+                }
+            )
+        check_round_trip(
+            df, pa, read_kwargs={"dtype_backend": "numpy_nullable"}, expected=expected
+        )
+
+
+class TestParquetPyArrow(Base):
+    def test_basic(self, pa, df_full):
+        df = df_full
+
+        # additional supported types for pyarrow
+        dti = pd.date_range("20130101", periods=3, tz="Europe/Brussels")
+        dti = dti._with_freq(None)  # freq doesn't round-trip
+        df["datetime_tz"] = dti
+        df["bool_with_none"] = [True, None, True]
+
+        check_round_trip(df, pa)
+
+    def test_basic_subset_columns(self, pa, df_full):
+        # GH18628
+
+        df = df_full
+        # additional supported types for pyarrow
+        df["datetime_tz"] = pd.date_range("20130101", periods=3, tz="Europe/Brussels")
+
+        check_round_trip(
+            df,
+            pa,
+            expected=df[["string", "int"]],
+            read_kwargs={"columns": ["string", "int"]},
+        )
+
+    def test_to_bytes_without_path_or_buf_provided(self, pa, df_full):
+        # GH 37105
+        buf_bytes = df_full.to_parquet(engine=pa)
+        assert isinstance(buf_bytes, bytes)
+
+        buf_stream = BytesIO(buf_bytes)
+        res = read_parquet(buf_stream)
+
+        expected = df_full.copy()
+        expected.loc[1, "string_with_nan"] = None
+        tm.assert_frame_equal(res, expected)
+
+    def test_duplicate_columns(self, pa):
+        # not currently able to handle duplicate columns
+        df = pd.DataFrame(np.arange(12).reshape(4, 3), columns=list("aaa")).copy()
+        self.check_error_on_write(df, pa, ValueError, "Duplicate column names found")
+
+    def test_timedelta(self, pa):
+        df = pd.DataFrame({"a": pd.timedelta_range("1 day", periods=3)})
+        check_round_trip(df, pa)
+
+    def test_unsupported(self, pa):
+        # mixed python objects
+        df = pd.DataFrame({"a": ["a", 1, 2.0]})
+        # pyarrow 0.11 raises ArrowTypeError
+        # older pyarrows raise ArrowInvalid
+        self.check_external_error_on_write(df, pa, pyarrow.ArrowException)
+
+    def test_unsupported_float16(self, pa):
+        # #44847, #44914
+        # Not able to write float 16 column using pyarrow.
+        data = np.arange(2, 10, dtype=np.float16)
+        df = pd.DataFrame(data=data, columns=["fp16"])
+        if pa_version_under15p0:
+            self.check_external_error_on_write(df, pa, pyarrow.ArrowException)
+        else:
+            check_round_trip(df, pa)
+
+    @pytest.mark.xfail(
+        is_platform_windows(),
+        reason=(
+            "PyArrow does not cleanup of partial files dumps when unsupported "
+            "dtypes are passed to_parquet function in windows"
+        ),
+    )
+    @pytest.mark.skipif(not pa_version_under15p0, reason="float16 works on 15")
+    @pytest.mark.parametrize("path_type", [str, pathlib.Path])
+    def test_unsupported_float16_cleanup(self, pa, path_type):
+        # #44847, #44914
+        # Not able to write float 16 column using pyarrow.
+        # Tests cleanup by pyarrow in case of an error
+        data = np.arange(2, 10, dtype=np.float16)
+        df = pd.DataFrame(data=data, columns=["fp16"])
+
+        with tm.ensure_clean() as path_str:
+            path = path_type(path_str)
+            with tm.external_error_raised(pyarrow.ArrowException):
+                df.to_parquet(path=path, engine=pa)
+            assert not os.path.isfile(path)
+
+    def test_categorical(self, pa):
+        # supported in >= 0.7.0
+        df = pd.DataFrame()
+        df["a"] = pd.Categorical(list("abcdef"))
+
+        # test for null, out-of-order values, and unobserved category
+        df["b"] = pd.Categorical(
+            ["bar", "foo", "foo", "bar", None, "bar"],
+            dtype=pd.CategoricalDtype(["foo", "bar", "baz"]),
+        )
+
+        # test for ordered flag
+        df["c"] = pd.Categorical(
+            ["a", "b", "c", "a", "c", "b"], categories=["b", "c", "d"], ordered=True
+        )
+
+        check_round_trip(df, pa)
+
+    @pytest.mark.single_cpu
+    def test_s3_roundtrip_explicit_fs(self, df_compat, s3_public_bucket, pa, s3so):
+        s3fs = pytest.importorskip("s3fs")
+        s3 = s3fs.S3FileSystem(**s3so)
+        kw = {"filesystem": s3}
+        check_round_trip(
+            df_compat,
+            pa,
+            path=f"{s3_public_bucket.name}/pyarrow.parquet",
+            read_kwargs=kw,
+            write_kwargs=kw,
+        )
+
+    @pytest.mark.single_cpu
+    def test_s3_roundtrip(self, df_compat, s3_public_bucket, pa, s3so):
+        # GH #19134
+        s3so = {"storage_options": s3so}
+        check_round_trip(
+            df_compat,
+            pa,
+            path=f"s3://{s3_public_bucket.name}/pyarrow.parquet",
+            read_kwargs=s3so,
+            write_kwargs=s3so,
+        )
+
+    @pytest.mark.single_cpu
+    @pytest.mark.parametrize(
+        "partition_col",
+        [
+            ["A"],
+            [],
+        ],
+    )
+    def test_s3_roundtrip_for_dir(
+        self, df_compat, s3_public_bucket, pa, partition_col, s3so
+    ):
+        pytest.importorskip("s3fs")
+        # GH #26388
+        expected_df = df_compat.copy()
+
+        # GH #35791
+        if partition_col:
+            expected_df = expected_df.astype(dict.fromkeys(partition_col, np.int32))
+            partition_col_type = "category"
+
+            expected_df[partition_col] = expected_df[partition_col].astype(
+                partition_col_type
+            )
+
+        check_round_trip(
+            df_compat,
+            pa,
+            expected=expected_df,
+            path=f"s3://{s3_public_bucket.name}/parquet_dir",
+            read_kwargs={"storage_options": s3so},
+            write_kwargs={
+                "partition_cols": partition_col,
+                "compression": None,
+                "storage_options": s3so,
+            },
+            check_like=True,
+            repeat=1,
+        )
+
+    def test_read_file_like_obj_support(self, df_compat):
+        pytest.importorskip("pyarrow")
+        buffer = BytesIO()
+        df_compat.to_parquet(buffer)
+        df_from_buf = read_parquet(buffer)
+        tm.assert_frame_equal(df_compat, df_from_buf)
+
+    def test_expand_user(self, df_compat, monkeypatch):
+        pytest.importorskip("pyarrow")
+        monkeypatch.setenv("HOME", "TestingUser")
+        monkeypatch.setenv("USERPROFILE", "TestingUser")
+        with pytest.raises(OSError, match=r".*TestingUser.*"):
+            read_parquet("~/file.parquet")
+        with pytest.raises(OSError, match=r".*TestingUser.*"):
+            df_compat.to_parquet("~/file.parquet")
+
+    def test_partition_cols_supported(self, tmp_path, pa, df_full):
+        # GH #23283
+        partition_cols = ["bool", "int"]
+        df = df_full
+        df.to_parquet(tmp_path, partition_cols=partition_cols, compression=None)
+        check_partition_names(tmp_path, partition_cols)
+        assert read_parquet(tmp_path).shape == df.shape
+
+    def test_partition_cols_string(self, tmp_path, pa, df_full):
+        # GH #27117
+        partition_cols = "bool"
+        partition_cols_list = [partition_cols]
+        df = df_full
+        df.to_parquet(tmp_path, partition_cols=partition_cols, compression=None)
+        check_partition_names(tmp_path, partition_cols_list)
+        assert read_parquet(tmp_path).shape == df.shape
+
+    @pytest.mark.parametrize(
+        "path_type", [str, lambda x: x], ids=["string", "pathlib.Path"]
+    )
+    def test_partition_cols_pathlib(self, tmp_path, pa, df_compat, path_type):
+        # GH 35902
+
+        partition_cols = "B"
+        partition_cols_list = [partition_cols]
+        df = df_compat
+
+        path = path_type(tmp_path)
+        df.to_parquet(path, partition_cols=partition_cols_list)
+        assert read_parquet(path).shape == df.shape
+
+    def test_empty_dataframe(self, pa):
+        # GH #27339
+        df = pd.DataFrame(index=[], columns=[])
+        check_round_trip(df, pa)
+
+    def test_write_with_schema(self, pa):
+        import pyarrow
+
+        df = pd.DataFrame({"x": [0, 1]})
+        schema = pyarrow.schema([pyarrow.field("x", type=pyarrow.bool_())])
+        out_df = df.astype(bool)
+        check_round_trip(df, pa, write_kwargs={"schema": schema}, expected=out_df)
+
+    def test_additional_extension_arrays(self, pa):
+        # test additional ExtensionArrays that are supported through the
+        # __arrow_array__ protocol
+        pytest.importorskip("pyarrow")
+        df = pd.DataFrame(
+            {
+                "a": pd.Series([1, 2, 3], dtype="Int64"),
+                "b": pd.Series([1, 2, 3], dtype="UInt32"),
+                "c": pd.Series(["a", None, "c"], dtype="string"),
+            }
+        )
+        check_round_trip(df, pa)
+
+        df = pd.DataFrame({"a": pd.Series([1, 2, 3, None], dtype="Int64")})
+        check_round_trip(df, pa)
+
+    def test_pyarrow_backed_string_array(self, pa, string_storage):
+        # test ArrowStringArray supported through the __arrow_array__ protocol
+        pytest.importorskip("pyarrow")
+        df = pd.DataFrame({"a": pd.Series(["a", None, "c"], dtype="string[pyarrow]")})
+        with pd.option_context("string_storage", string_storage):
+            check_round_trip(df, pa, expected=df.astype(f"string[{string_storage}]"))
+
+    def test_additional_extension_types(self, pa):
+        # test additional ExtensionArrays that are supported through the
+        # __arrow_array__ protocol + by defining a custom ExtensionType
+        pytest.importorskip("pyarrow")
+        df = pd.DataFrame(
+            {
+                "c": pd.IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)]),
+                "d": pd.period_range("2012-01-01", periods=3, freq="D"),
+                # GH-45881 issue with interval with datetime64[ns] subtype
+                "e": pd.IntervalIndex.from_breaks(
+                    pd.date_range("2012-01-01", periods=4, freq="D")
+                ),
+            }
+        )
+        check_round_trip(df, pa)
+
+    def test_timestamp_nanoseconds(self, pa):
+        # with version 2.6, pyarrow defaults to writing the nanoseconds, so
+        # this should work without error
+        # Note in previous pyarrows(<7.0.0), only the pseudo-version 2.0 was available
+        ver = "2.6"
+        df = pd.DataFrame({"a": pd.date_range("2017-01-01", freq="1ns", periods=10)})
+        check_round_trip(df, pa, write_kwargs={"version": ver})
+
+    def test_timezone_aware_index(self, request, pa, timezone_aware_date_list):
+        if timezone_aware_date_list.tzinfo != datetime.timezone.utc:
+            request.applymarker(
+                pytest.mark.xfail(
+                    reason="temporary skip this test until it is properly resolved: "
+                    "https://github.com/pandas-dev/pandas/issues/37286"
+                )
+            )
+        idx = 5 * [timezone_aware_date_list]
+        df = pd.DataFrame(index=idx, data={"index_as_col": idx})
+
+        # see gh-36004
+        # compare time(zone) values only, skip their class:
+        # pyarrow always creates fixed offset timezones using pytz.FixedOffset()
+        # even if it was datetime.timezone() originally
+        #
+        # technically they are the same:
+        # they both implement datetime.tzinfo
+        # they both wrap datetime.timedelta()
+        # this use-case sets the resolution to 1 minute
+        check_round_trip(df, pa, check_dtype=False)
+
+    def test_filter_row_groups(self, pa):
+        # https://github.com/pandas-dev/pandas/issues/26551
+        pytest.importorskip("pyarrow")
+        df = pd.DataFrame({"a": list(range(3))})
+        with tm.ensure_clean() as path:
+            df.to_parquet(path, engine=pa)
+            result = read_parquet(path, pa, filters=[("a", "==", 0)])
+        assert len(result) == 1
+
+    def test_read_parquet_manager(self, pa, using_array_manager):
+        # ensure that read_parquet honors the pandas.options.mode.data_manager option
+        df = pd.DataFrame(
+            np.random.default_rng(2).standard_normal((10, 3)), columns=["A", "B", "C"]
+        )
+
+        with tm.ensure_clean() as path:
+            df.to_parquet(path, engine=pa)
+            result = read_parquet(path, pa)
+        if using_array_manager:
+            assert isinstance(result._mgr, pd.core.internals.ArrayManager)
+        else:
+            assert isinstance(result._mgr, pd.core.internals.BlockManager)
+
+    def test_read_dtype_backend_pyarrow_config(self, pa, df_full):
+        import pyarrow
+
+        df = df_full
+
+        # additional supported types for pyarrow
+        dti = pd.date_range("20130101", periods=3, tz="Europe/Brussels")
+        dti = dti._with_freq(None)  # freq doesn't round-trip
+        df["datetime_tz"] = dti
+        df["bool_with_none"] = [True, None, True]
+
+        pa_table = pyarrow.Table.from_pandas(df)
+        expected = pa_table.to_pandas(types_mapper=pd.ArrowDtype)
+        if pa_version_under13p0:
+            # pyarrow infers datetimes as us instead of ns
+            expected["datetime"] = expected["datetime"].astype("timestamp[us][pyarrow]")
+            expected["datetime_with_nat"] = expected["datetime_with_nat"].astype(
+                "timestamp[us][pyarrow]"
+            )
+            expected["datetime_tz"] = expected["datetime_tz"].astype(
+                pd.ArrowDtype(pyarrow.timestamp(unit="us", tz="Europe/Brussels"))
+            )
+
+        check_round_trip(
+            df,
+            engine=pa,
+            read_kwargs={"dtype_backend": "pyarrow"},
+            expected=expected,
+        )
+
+    def test_read_dtype_backend_pyarrow_config_index(self, pa):
+        df = pd.DataFrame(
+            {"a": [1, 2]}, index=pd.Index([3, 4], name="test"), dtype="int64[pyarrow]"
+        )
+        expected = df.copy()
+        import pyarrow
+
+        if Version(pyarrow.__version__) > Version("11.0.0"):
+            expected.index = expected.index.astype("int64[pyarrow]")
+        check_round_trip(
+            df,
+            engine=pa,
+            read_kwargs={"dtype_backend": "pyarrow"},
+            expected=expected,
+        )
+
+    def test_columns_dtypes_not_invalid(self, pa):
+        df = pd.DataFrame({"string": list("abc"), "int": list(range(1, 4))})
+
+        # numeric
+        df.columns = [0, 1]
+        check_round_trip(df, pa)
+
+        # bytes
+        df.columns = [b"foo", b"bar"]
+        with pytest.raises(NotImplementedError, match="|S3"):
+            # Bytes fails on read_parquet
+            check_round_trip(df, pa)
+
+        # python object
+        df.columns = [
+            datetime.datetime(2011, 1, 1, 0, 0),
+            datetime.datetime(2011, 1, 1, 1, 1),
+        ]
+        check_round_trip(df, pa)
+
+    def test_empty_columns(self, pa):
+        # GH 52034
+        df = pd.DataFrame(index=pd.Index(["a", "b", "c"], name="custom name"))
+        check_round_trip(df, pa)
+
+    def test_df_attrs_persistence(self, tmp_path, pa):
+        path = tmp_path / "test_df_metadata.p"
+        df = pd.DataFrame(data={1: [1]})
+        df.attrs = {"test_attribute": 1}
+        df.to_parquet(path, engine=pa)
+        new_df = read_parquet(path, engine=pa)
+        assert new_df.attrs == df.attrs
+
+    def test_string_inference(self, tmp_path, pa):
+        # GH#54431
+        path = tmp_path / "test_string_inference.p"
+        df = pd.DataFrame(data={"a": ["x", "y"]}, index=["a", "b"])
+        df.to_parquet(path, engine="pyarrow")
+        with pd.option_context("future.infer_string", True):
+            result = read_parquet(path, engine="pyarrow")
+        expected = pd.DataFrame(
+            data={"a": ["x", "y"]},
+            dtype="string[pyarrow_numpy]",
+            index=pd.Index(["a", "b"], dtype="string[pyarrow_numpy]"),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.skipif(pa_version_under11p0, reason="not supported before 11.0")
+    def test_roundtrip_decimal(self, tmp_path, pa):
+        # GH#54768
+        import pyarrow as pa
+
+        path = tmp_path / "decimal.p"
+        df = pd.DataFrame({"a": [Decimal("123.00")]}, dtype="string[pyarrow]")
+        df.to_parquet(path, schema=pa.schema([("a", pa.decimal128(5))]))
+        result = read_parquet(path)
+        expected = pd.DataFrame({"a": ["123"]}, dtype="string[python]")
+        tm.assert_frame_equal(result, expected)
+
+    def test_infer_string_large_string_type(self, tmp_path, pa):
+        # GH#54798
+        import pyarrow as pa
+        import pyarrow.parquet as pq
+
+        path = tmp_path / "large_string.p"
+
+        table = pa.table({"a": pa.array([None, "b", "c"], pa.large_string())})
+        pq.write_table(table, path)
+
+        with pd.option_context("future.infer_string", True):
+            result = read_parquet(path)
+        expected = pd.DataFrame(
+            data={"a": [None, "b", "c"]},
+            dtype="string[pyarrow_numpy]",
+            columns=pd.Index(["a"], dtype="string[pyarrow_numpy]"),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    # NOTE: this test is not run by default, because it requires a lot of memory (>5GB)
+    # @pytest.mark.slow
+    # def test_string_column_above_2GB(self, tmp_path, pa):
+    #     # https://github.com/pandas-dev/pandas/issues/55606
+    #     # above 2GB of string data
+    #     v1 = b"x" * 100000000
+    #     v2 = b"x" * 147483646
+    #     df = pd.DataFrame({"strings": [v1] * 20 + [v2] + ["x"] * 20}, dtype="string")
+    #     df.to_parquet(tmp_path / "test.parquet")
+    #     result = read_parquet(tmp_path / "test.parquet")
+    #     assert result["strings"].dtype == "string"
+
+
+class TestParquetFastParquet(Base):
+    def test_basic(self, fp, df_full):
+        df = df_full
+
+        dti = pd.date_range("20130101", periods=3, tz="US/Eastern")
+        dti = dti._with_freq(None)  # freq doesn't round-trip
+        df["datetime_tz"] = dti
+        df["timedelta"] = pd.timedelta_range("1 day", periods=3)
+        check_round_trip(df, fp)
+
+    def test_columns_dtypes_invalid(self, fp):
+        df = pd.DataFrame({"string": list("abc"), "int": list(range(1, 4))})
+
+        err = TypeError
+        msg = "Column name must be a string"
+
+        # numeric
+        df.columns = [0, 1]
+        self.check_error_on_write(df, fp, err, msg)
+
+        # bytes
+        df.columns = [b"foo", b"bar"]
+        self.check_error_on_write(df, fp, err, msg)
+
+        # python object
+        df.columns = [
+            datetime.datetime(2011, 1, 1, 0, 0),
+            datetime.datetime(2011, 1, 1, 1, 1),
+        ]
+        self.check_error_on_write(df, fp, err, msg)
+
+    def test_duplicate_columns(self, fp):
+        # not currently able to handle duplicate columns
+        df = pd.DataFrame(np.arange(12).reshape(4, 3), columns=list("aaa")).copy()
+        msg = "Cannot create parquet dataset with duplicate column names"
+        self.check_error_on_write(df, fp, ValueError, msg)
+
+    def test_bool_with_none(self, fp):
+        df = pd.DataFrame({"a": [True, None, False]})
+        expected = pd.DataFrame({"a": [1.0, np.nan, 0.0]}, dtype="float16")
+        # Fastparquet bug in 0.7.1 makes it so that this dtype becomes
+        # float64
+        check_round_trip(df, fp, expected=expected, check_dtype=False)
+
+    def test_unsupported(self, fp):
+        # period
+        df = pd.DataFrame({"a": pd.period_range("2013", freq="M", periods=3)})
+        # error from fastparquet -> don't check exact error message
+        self.check_error_on_write(df, fp, ValueError, None)
+
+        # mixed
+        df = pd.DataFrame({"a": ["a", 1, 2.0]})
+        msg = "Can't infer object conversion type"
+        self.check_error_on_write(df, fp, ValueError, msg)
+
+    def test_categorical(self, fp):
+        df = pd.DataFrame({"a": pd.Categorical(list("abc"))})
+        check_round_trip(df, fp)
+
+    def test_filter_row_groups(self, fp):
+        d = {"a": list(range(3))}
+        df = pd.DataFrame(d)
+        with tm.ensure_clean() as path:
+            df.to_parquet(path, engine=fp, compression=None, row_group_offsets=1)
+            result = read_parquet(path, fp, filters=[("a", "==", 0)])
+        assert len(result) == 1
+
+    @pytest.mark.single_cpu
+    def test_s3_roundtrip(self, df_compat, s3_public_bucket, fp, s3so):
+        # GH #19134
+        check_round_trip(
+            df_compat,
+            fp,
+            path=f"s3://{s3_public_bucket.name}/fastparquet.parquet",
+            read_kwargs={"storage_options": s3so},
+            write_kwargs={"compression": None, "storage_options": s3so},
+        )
+
+    def test_partition_cols_supported(self, tmp_path, fp, df_full):
+        # GH #23283
+        partition_cols = ["bool", "int"]
+        df = df_full
+        df.to_parquet(
+            tmp_path,
+            engine="fastparquet",
+            partition_cols=partition_cols,
+            compression=None,
+        )
+        assert os.path.exists(tmp_path)
+        import fastparquet
+
+        actual_partition_cols = fastparquet.ParquetFile(str(tmp_path), False).cats
+        assert len(actual_partition_cols) == 2
+
+    def test_partition_cols_string(self, tmp_path, fp, df_full):
+        # GH #27117
+        partition_cols = "bool"
+        df = df_full
+        df.to_parquet(
+            tmp_path,
+            engine="fastparquet",
+            partition_cols=partition_cols,
+            compression=None,
+        )
+        assert os.path.exists(tmp_path)
+        import fastparquet
+
+        actual_partition_cols = fastparquet.ParquetFile(str(tmp_path), False).cats
+        assert len(actual_partition_cols) == 1
+
+    def test_partition_on_supported(self, tmp_path, fp, df_full):
+        # GH #23283
+        partition_cols = ["bool", "int"]
+        df = df_full
+        df.to_parquet(
+            tmp_path,
+            engine="fastparquet",
+            compression=None,
+            partition_on=partition_cols,
+        )
+        assert os.path.exists(tmp_path)
+        import fastparquet
+
+        actual_partition_cols = fastparquet.ParquetFile(str(tmp_path), False).cats
+        assert len(actual_partition_cols) == 2
+
+    def test_error_on_using_partition_cols_and_partition_on(
+        self, tmp_path, fp, df_full
+    ):
+        # GH #23283
+        partition_cols = ["bool", "int"]
+        df = df_full
+        msg = (
+            "Cannot use both partition_on and partition_cols. Use partition_cols for "
+            "partitioning data"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.to_parquet(
+                tmp_path,
+                engine="fastparquet",
+                compression=None,
+                partition_on=partition_cols,
+                partition_cols=partition_cols,
+            )
+
+    @pytest.mark.skipif(using_copy_on_write(), reason="fastparquet writes into Index")
+    def test_empty_dataframe(self, fp):
+        # GH #27339
+        df = pd.DataFrame()
+        expected = df.copy()
+        check_round_trip(df, fp, expected=expected)
+
+    @pytest.mark.skipif(using_copy_on_write(), reason="fastparquet writes into Index")
+    def test_timezone_aware_index(self, fp, timezone_aware_date_list):
+        idx = 5 * [timezone_aware_date_list]
+
+        df = pd.DataFrame(index=idx, data={"index_as_col": idx})
+
+        expected = df.copy()
+        expected.index.name = "index"
+        check_round_trip(df, fp, expected=expected)
+
+    def test_use_nullable_dtypes_not_supported(self, fp):
+        df = pd.DataFrame({"a": [1, 2]})
+
+        with tm.ensure_clean() as path:
+            df.to_parquet(path)
+            with pytest.raises(ValueError, match="not supported for the fastparquet"):
+                with tm.assert_produces_warning(FutureWarning):
+                    read_parquet(path, engine="fastparquet", use_nullable_dtypes=True)
+            with pytest.raises(ValueError, match="not supported for the fastparquet"):
+                read_parquet(path, engine="fastparquet", dtype_backend="pyarrow")
+
+    def test_close_file_handle_on_read_error(self):
+        with tm.ensure_clean("test.parquet") as path:
+            pathlib.Path(path).write_bytes(b"breakit")
+            with pytest.raises(Exception, match=""):  # Not important which exception
+                read_parquet(path, engine="fastparquet")
+            # The next line raises an error on Windows if the file is still open
+            pathlib.Path(path).unlink(missing_ok=False)
+
+    def test_bytes_file_name(self, engine):
+        # GH#48944
+        df = pd.DataFrame(data={"A": [0, 1], "B": [1, 0]})
+        with tm.ensure_clean("test.parquet") as path:
+            with open(path.encode(), "wb") as f:
+                df.to_parquet(f)
+
+            result = read_parquet(path, engine=engine)
+        tm.assert_frame_equal(result, df)
+
+    def test_filesystem_notimplemented(self):
+        pytest.importorskip("fastparquet")
+        df = pd.DataFrame(data={"A": [0, 1], "B": [1, 0]})
+        with tm.ensure_clean() as path:
+            with pytest.raises(
+                NotImplementedError, match="filesystem is not implemented"
+            ):
+                df.to_parquet(path, engine="fastparquet", filesystem="foo")
+
+        with tm.ensure_clean() as path:
+            pathlib.Path(path).write_bytes(b"foo")
+            with pytest.raises(
+                NotImplementedError, match="filesystem is not implemented"
+            ):
+                read_parquet(path, engine="fastparquet", filesystem="foo")
+
+    def test_invalid_filesystem(self):
+        pytest.importorskip("pyarrow")
+        df = pd.DataFrame(data={"A": [0, 1], "B": [1, 0]})
+        with tm.ensure_clean() as path:
+            with pytest.raises(
+                ValueError, match="filesystem must be a pyarrow or fsspec FileSystem"
+            ):
+                df.to_parquet(path, engine="pyarrow", filesystem="foo")
+
+        with tm.ensure_clean() as path:
+            pathlib.Path(path).write_bytes(b"foo")
+            with pytest.raises(
+                ValueError, match="filesystem must be a pyarrow or fsspec FileSystem"
+            ):
+                read_parquet(path, engine="pyarrow", filesystem="foo")
+
+    def test_unsupported_pa_filesystem_storage_options(self):
+        pa_fs = pytest.importorskip("pyarrow.fs")
+        df = pd.DataFrame(data={"A": [0, 1], "B": [1, 0]})
+        with tm.ensure_clean() as path:
+            with pytest.raises(
+                NotImplementedError,
+                match="storage_options not supported with a pyarrow FileSystem.",
+            ):
+                df.to_parquet(
+                    path,
+                    engine="pyarrow",
+                    filesystem=pa_fs.LocalFileSystem(),
+                    storage_options={"foo": "bar"},
+                )
+
+        with tm.ensure_clean() as path:
+            pathlib.Path(path).write_bytes(b"foo")
+            with pytest.raises(
+                NotImplementedError,
+                match="storage_options not supported with a pyarrow FileSystem.",
+            ):
+                read_parquet(
+                    path,
+                    engine="pyarrow",
+                    filesystem=pa_fs.LocalFileSystem(),
+                    storage_options={"foo": "bar"},
+                )
+
+    def test_invalid_dtype_backend(self, engine):
+        msg = (
+            "dtype_backend numpy is invalid, only 'numpy_nullable' and "
+            "'pyarrow' are allowed."
+        )
+        df = pd.DataFrame({"int": list(range(1, 4))})
+        with tm.ensure_clean("tmp.parquet") as path:
+            df.to_parquet(path)
+            with pytest.raises(ValueError, match=msg):
+                read_parquet(path, dtype_backend="numpy")
+
+    @pytest.mark.skipif(using_copy_on_write(), reason="fastparquet writes into Index")
+    def test_empty_columns(self, fp):
+        # GH 52034
+        df = pd.DataFrame(index=pd.Index(["a", "b", "c"], name="custom name"))
+        expected = pd.DataFrame(index=pd.Index(["a", "b", "c"], name="custom name"))
+        check_round_trip(df, fp, expected=expected)

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

@@ -0,0 +1,652 @@
+"""
+manage legacy pickle tests
+
+How to add pickle tests:
+
+1. Install pandas version intended to output the pickle.
+
+2. Execute "generate_legacy_storage_files.py" to create the pickle.
+$ python generate_legacy_storage_files.py <output_dir> pickle
+
+3. Move the created pickle to "data/legacy_pickle/<version>" directory.
+"""
+from __future__ import annotations
+
+from array import array
+import bz2
+import datetime
+import functools
+from functools import partial
+import gzip
+import io
+import os
+from pathlib import Path
+import pickle
+import shutil
+import tarfile
+from typing import Any
+import uuid
+import zipfile
+
+import numpy as np
+import pytest
+
+from pandas.compat import (
+    get_lzma_file,
+    is_platform_little_endian,
+)
+from pandas.compat._optional import import_optional_dependency
+from pandas.compat.compressors import flatten_buffer
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    period_range,
+)
+import pandas._testing as tm
+from pandas.tests.io.generate_legacy_storage_files import create_pickle_data
+
+import pandas.io.common as icom
+from pandas.tseries.offsets import (
+    Day,
+    MonthEnd,
+)
+
+
+# ---------------------
+# comparison functions
+# ---------------------
+def compare_element(result, expected, typ):
+    if isinstance(expected, Index):
+        tm.assert_index_equal(expected, result)
+        return
+
+    if typ.startswith("sp_"):
+        tm.assert_equal(result, expected)
+    elif typ == "timestamp":
+        if expected is pd.NaT:
+            assert result is pd.NaT
+        else:
+            assert result == expected
+    else:
+        comparator = getattr(tm, f"assert_{typ}_equal", tm.assert_almost_equal)
+        comparator(result, expected)
+
+
+# ---------------------
+# tests
+# ---------------------
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        b"123",
+        b"123456",
+        bytearray(b"123"),
+        memoryview(b"123"),
+        pickle.PickleBuffer(b"123"),
+        array("I", [1, 2, 3]),
+        memoryview(b"123456").cast("B", (3, 2)),
+        memoryview(b"123456").cast("B", (3, 2))[::2],
+        np.arange(12).reshape((3, 4), order="C"),
+        np.arange(12).reshape((3, 4), order="F"),
+        np.arange(12).reshape((3, 4), order="C")[:, ::2],
+    ],
+)
+def test_flatten_buffer(data):
+    result = flatten_buffer(data)
+    expected = memoryview(data).tobytes("A")
+    assert result == expected
+    if isinstance(data, (bytes, bytearray)):
+        assert result is data
+    elif isinstance(result, memoryview):
+        assert result.ndim == 1
+        assert result.format == "B"
+        assert result.contiguous
+        assert result.shape == (result.nbytes,)
+
+
+def test_pickles(datapath):
+    if not is_platform_little_endian():
+        pytest.skip("known failure on non-little endian")
+
+    # For loop for compat with --strict-data-files
+    for legacy_pickle in Path(__file__).parent.glob("data/legacy_pickle/*/*.p*kl*"):
+        legacy_pickle = datapath(legacy_pickle)
+
+        data = pd.read_pickle(legacy_pickle)
+
+        for typ, dv in data.items():
+            for dt, result in dv.items():
+                expected = data[typ][dt]
+
+                if typ == "series" and dt == "ts":
+                    # GH 7748
+                    tm.assert_series_equal(result, expected)
+                    assert result.index.freq == expected.index.freq
+                    assert not result.index.freq.normalize
+                    tm.assert_series_equal(result > 0, expected > 0)
+
+                    # GH 9291
+                    freq = result.index.freq
+                    assert freq + Day(1) == Day(2)
+
+                    res = freq + pd.Timedelta(hours=1)
+                    assert isinstance(res, pd.Timedelta)
+                    assert res == pd.Timedelta(days=1, hours=1)
+
+                    res = freq + pd.Timedelta(nanoseconds=1)
+                    assert isinstance(res, pd.Timedelta)
+                    assert res == pd.Timedelta(days=1, nanoseconds=1)
+                elif typ == "index" and dt == "period":
+                    tm.assert_index_equal(result, expected)
+                    assert isinstance(result.freq, MonthEnd)
+                    assert result.freq == MonthEnd()
+                    assert result.freqstr == "M"
+                    tm.assert_index_equal(result.shift(2), expected.shift(2))
+                elif typ == "series" and dt in ("dt_tz", "cat"):
+                    tm.assert_series_equal(result, expected)
+                elif typ == "frame" and dt in (
+                    "dt_mixed_tzs",
+                    "cat_onecol",
+                    "cat_and_float",
+                ):
+                    tm.assert_frame_equal(result, expected)
+                else:
+                    compare_element(result, expected, typ)
+
+
+def python_pickler(obj, path):
+    with open(path, "wb") as fh:
+        pickle.dump(obj, fh, protocol=-1)
+
+
+def python_unpickler(path):
+    with open(path, "rb") as fh:
+        fh.seek(0)
+        return pickle.load(fh)
+
+
+def flatten(data: dict) -> list[tuple[str, Any]]:
+    """Flatten create_pickle_data"""
+    return [
+        (typ, example)
+        for typ, examples in data.items()
+        for example in examples.values()
+    ]
+
+
+@pytest.mark.parametrize(
+    "pickle_writer",
+    [
+        pytest.param(python_pickler, id="python"),
+        pytest.param(pd.to_pickle, id="pandas_proto_default"),
+        pytest.param(
+            functools.partial(pd.to_pickle, protocol=pickle.HIGHEST_PROTOCOL),
+            id="pandas_proto_highest",
+        ),
+        pytest.param(functools.partial(pd.to_pickle, protocol=4), id="pandas_proto_4"),
+        pytest.param(
+            functools.partial(pd.to_pickle, protocol=5),
+            id="pandas_proto_5",
+        ),
+    ],
+)
+@pytest.mark.parametrize("writer", [pd.to_pickle, python_pickler])
+@pytest.mark.parametrize("typ, expected", flatten(create_pickle_data()))
+def test_round_trip_current(typ, expected, pickle_writer, writer):
+    with tm.ensure_clean() as path:
+        # test writing with each pickler
+        pickle_writer(expected, path)
+
+        # test reading with each unpickler
+        result = pd.read_pickle(path)
+        compare_element(result, expected, typ)
+
+        result = python_unpickler(path)
+        compare_element(result, expected, typ)
+
+        # and the same for file objects (GH 35679)
+        with open(path, mode="wb") as handle:
+            writer(expected, path)
+            handle.seek(0)  # shouldn't close file handle
+        with open(path, mode="rb") as handle:
+            result = pd.read_pickle(handle)
+            handle.seek(0)  # shouldn't close file handle
+        compare_element(result, expected, typ)
+
+
+def test_pickle_path_pathlib():
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+    result = tm.round_trip_pathlib(df.to_pickle, pd.read_pickle)
+    tm.assert_frame_equal(df, result)
+
+
+def test_pickle_path_localpath():
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+    result = tm.round_trip_localpath(df.to_pickle, pd.read_pickle)
+    tm.assert_frame_equal(df, result)
+
+
+# ---------------------
+# test pickle compression
+# ---------------------
+
+
+@pytest.fixture
+def get_random_path():
+    return f"__{uuid.uuid4()}__.pickle"
+
+
+class TestCompression:
+    _extension_to_compression = icom.extension_to_compression
+
+    def compress_file(self, src_path, dest_path, compression):
+        if compression is None:
+            shutil.copyfile(src_path, dest_path)
+            return
+
+        if compression == "gzip":
+            f = gzip.open(dest_path, "w")
+        elif compression == "bz2":
+            f = bz2.BZ2File(dest_path, "w")
+        elif compression == "zip":
+            with zipfile.ZipFile(dest_path, "w", compression=zipfile.ZIP_DEFLATED) as f:
+                f.write(src_path, os.path.basename(src_path))
+        elif compression == "tar":
+            with open(src_path, "rb") as fh:
+                with tarfile.open(dest_path, mode="w") as tar:
+                    tarinfo = tar.gettarinfo(src_path, os.path.basename(src_path))
+                    tar.addfile(tarinfo, fh)
+        elif compression == "xz":
+            f = get_lzma_file()(dest_path, "w")
+        elif compression == "zstd":
+            f = import_optional_dependency("zstandard").open(dest_path, "wb")
+        else:
+            msg = f"Unrecognized compression type: {compression}"
+            raise ValueError(msg)
+
+        if compression not in ["zip", "tar"]:
+            with open(src_path, "rb") as fh:
+                with f:
+                    f.write(fh.read())
+
+    def test_write_explicit(self, compression, get_random_path):
+        base = get_random_path
+        path1 = base + ".compressed"
+        path2 = base + ".raw"
+
+        with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
+
+            # write to compressed file
+            df.to_pickle(p1, compression=compression)
+
+            # decompress
+            with tm.decompress_file(p1, compression=compression) as f:
+                with open(p2, "wb") as fh:
+                    fh.write(f.read())
+
+            # read decompressed file
+            df2 = pd.read_pickle(p2, compression=None)
+
+            tm.assert_frame_equal(df, df2)
+
+    @pytest.mark.parametrize("compression", ["", "None", "bad", "7z"])
+    def test_write_explicit_bad(self, compression, get_random_path):
+        with pytest.raises(ValueError, match="Unrecognized compression type"):
+            with tm.ensure_clean(get_random_path) as path:
+                df = DataFrame(
+                    1.1 * np.arange(120).reshape((30, 4)),
+                    columns=Index(list("ABCD"), dtype=object),
+                    index=Index([f"i-{i}" for i in range(30)], dtype=object),
+                )
+                df.to_pickle(path, compression=compression)
+
+    def test_write_infer(self, compression_ext, get_random_path):
+        base = get_random_path
+        path1 = base + compression_ext
+        path2 = base + ".raw"
+        compression = self._extension_to_compression.get(compression_ext.lower())
+
+        with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
+
+            # write to compressed file by inferred compression method
+            df.to_pickle(p1)
+
+            # decompress
+            with tm.decompress_file(p1, compression=compression) as f:
+                with open(p2, "wb") as fh:
+                    fh.write(f.read())
+
+            # read decompressed file
+            df2 = pd.read_pickle(p2, compression=None)
+
+            tm.assert_frame_equal(df, df2)
+
+    def test_read_explicit(self, compression, get_random_path):
+        base = get_random_path
+        path1 = base + ".raw"
+        path2 = base + ".compressed"
+
+        with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
+
+            # write to uncompressed file
+            df.to_pickle(p1, compression=None)
+
+            # compress
+            self.compress_file(p1, p2, compression=compression)
+
+            # read compressed file
+            df2 = pd.read_pickle(p2, compression=compression)
+            tm.assert_frame_equal(df, df2)
+
+    def test_read_infer(self, compression_ext, get_random_path):
+        base = get_random_path
+        path1 = base + ".raw"
+        path2 = base + compression_ext
+        compression = self._extension_to_compression.get(compression_ext.lower())
+
+        with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
+
+            # write to uncompressed file
+            df.to_pickle(p1, compression=None)
+
+            # compress
+            self.compress_file(p1, p2, compression=compression)
+
+            # read compressed file by inferred compression method
+            df2 = pd.read_pickle(p2)
+            tm.assert_frame_equal(df, df2)
+
+
+# ---------------------
+# test pickle compression
+# ---------------------
+
+
+class TestProtocol:
+    @pytest.mark.parametrize("protocol", [-1, 0, 1, 2])
+    def test_read(self, protocol, get_random_path):
+        with tm.ensure_clean(get_random_path) as path:
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
+            df.to_pickle(path, protocol=protocol)
+            df2 = pd.read_pickle(path)
+            tm.assert_frame_equal(df, df2)
+
+
+@pytest.mark.parametrize(
+    ["pickle_file", "excols"],
+    [
+        ("test_py27.pkl", Index(["a", "b", "c"])),
+        (
+            "test_mi_py27.pkl",
+            pd.MultiIndex.from_arrays([["a", "b", "c"], ["A", "B", "C"]]),
+        ),
+    ],
+)
+def test_unicode_decode_error(datapath, pickle_file, excols):
+    # pickle file written with py27, should be readable without raising
+    #  UnicodeDecodeError, see GH#28645 and GH#31988
+    path = datapath("io", "data", "pickle", pickle_file)
+    df = pd.read_pickle(path)
+
+    # just test the columns are correct since the values are random
+    tm.assert_index_equal(df.columns, excols)
+
+
+# ---------------------
+# tests for buffer I/O
+# ---------------------
+
+
+def test_pickle_buffer_roundtrip():
+    with tm.ensure_clean() as path:
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        with open(path, "wb") as fh:
+            df.to_pickle(fh)
+        with open(path, "rb") as fh:
+            result = pd.read_pickle(fh)
+        tm.assert_frame_equal(df, result)
+
+
+# ---------------------
+# tests for URL I/O
+# ---------------------
+
+
+@pytest.mark.parametrize(
+    "mockurl", ["http://url.com", "ftp://test.com", "http://gzip.com"]
+)
+def test_pickle_generalurl_read(monkeypatch, mockurl):
+    def python_pickler(obj, path):
+        with open(path, "wb") as fh:
+            pickle.dump(obj, fh, protocol=-1)
+
+    class MockReadResponse:
+        def __init__(self, path) -> None:
+            self.file = open(path, "rb")
+            if "gzip" in path:
+                self.headers = {"Content-Encoding": "gzip"}
+            else:
+                self.headers = {"Content-Encoding": ""}
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            self.close()
+
+        def read(self):
+            return self.file.read()
+
+        def close(self):
+            return self.file.close()
+
+    with tm.ensure_clean() as path:
+
+        def mock_urlopen_read(*args, **kwargs):
+            return MockReadResponse(path)
+
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        python_pickler(df, path)
+        monkeypatch.setattr("urllib.request.urlopen", mock_urlopen_read)
+        result = pd.read_pickle(mockurl)
+        tm.assert_frame_equal(df, result)
+
+
+def test_pickle_fsspec_roundtrip():
+    pytest.importorskip("fsspec")
+    with tm.ensure_clean():
+        mockurl = "memory://mockfile"
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        df.to_pickle(mockurl)
+        result = pd.read_pickle(mockurl)
+        tm.assert_frame_equal(df, result)
+
+
+class MyTz(datetime.tzinfo):
+    def __init__(self) -> None:
+        pass
+
+
+def test_read_pickle_with_subclass():
+    # GH 12163
+    expected = Series(dtype=object), MyTz()
+    result = tm.round_trip_pickle(expected)
+
+    tm.assert_series_equal(result[0], expected[0])
+    assert isinstance(result[1], MyTz)
+
+
+def test_pickle_binary_object_compression(compression):
+    """
+    Read/write from binary file-objects w/wo compression.
+
+    GH 26237, GH 29054, and GH 29570
+    """
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+
+    # reference for compression
+    with tm.ensure_clean() as path:
+        df.to_pickle(path, compression=compression)
+        reference = Path(path).read_bytes()
+
+    # write
+    buffer = io.BytesIO()
+    df.to_pickle(buffer, compression=compression)
+    buffer.seek(0)
+
+    # gzip  and zip safe the filename: cannot compare the compressed content
+    assert buffer.getvalue() == reference or compression in ("gzip", "zip", "tar")
+
+    # read
+    read_df = pd.read_pickle(buffer, compression=compression)
+    buffer.seek(0)
+    tm.assert_frame_equal(df, read_df)
+
+
+def test_pickle_dataframe_with_multilevel_index(
+    multiindex_year_month_day_dataframe_random_data,
+    multiindex_dataframe_random_data,
+):
+    ymd = multiindex_year_month_day_dataframe_random_data
+    frame = multiindex_dataframe_random_data
+
+    def _test_roundtrip(frame):
+        unpickled = tm.round_trip_pickle(frame)
+        tm.assert_frame_equal(frame, unpickled)
+
+    _test_roundtrip(frame)
+    _test_roundtrip(frame.T)
+    _test_roundtrip(ymd)
+    _test_roundtrip(ymd.T)
+
+
+def test_pickle_timeseries_periodindex():
+    # GH#2891
+    prng = period_range("1/1/2011", "1/1/2012", freq="M")
+    ts = Series(np.random.default_rng(2).standard_normal(len(prng)), prng)
+    new_ts = tm.round_trip_pickle(ts)
+    assert new_ts.index.freqstr == "M"
+
+
+@pytest.mark.parametrize(
+    "name", [777, 777.0, "name", datetime.datetime(2001, 11, 11), (1, 2)]
+)
+def test_pickle_preserve_name(name):
+    unpickled = tm.round_trip_pickle(Series(np.arange(10, dtype=np.float64), name=name))
+    assert unpickled.name == name
+
+
+def test_pickle_datetimes(datetime_series):
+    unp_ts = tm.round_trip_pickle(datetime_series)
+    tm.assert_series_equal(unp_ts, datetime_series)
+
+
+def test_pickle_strings(string_series):
+    unp_series = tm.round_trip_pickle(string_series)
+    tm.assert_series_equal(unp_series, string_series)
+
+
+@td.skip_array_manager_invalid_test
+def test_pickle_preserves_block_ndim():
+    # GH#37631
+    ser = Series(list("abc")).astype("category").iloc[[0]]
+    res = tm.round_trip_pickle(ser)
+
+    assert res._mgr.blocks[0].ndim == 1
+    assert res._mgr.blocks[0].shape == (1,)
+
+    # GH#37631 OP issue was about indexing, underlying problem was pickle
+    tm.assert_series_equal(res[[True]], ser)
+
+
+@pytest.mark.parametrize("protocol", [pickle.DEFAULT_PROTOCOL, pickle.HIGHEST_PROTOCOL])
+def test_pickle_big_dataframe_compression(protocol, compression):
+    # GH#39002
+    df = DataFrame(range(100000))
+    result = tm.round_trip_pathlib(
+        partial(df.to_pickle, protocol=protocol, compression=compression),
+        partial(pd.read_pickle, compression=compression),
+    )
+    tm.assert_frame_equal(df, result)
+
+
+def test_pickle_frame_v124_unpickle_130(datapath):
+    # GH#42345 DataFrame created in 1.2.x, unpickle in 1.3.x
+    path = datapath(
+        Path(__file__).parent,
+        "data",
+        "legacy_pickle",
+        "1.2.4",
+        "empty_frame_v1_2_4-GH#42345.pkl",
+    )
+    with open(path, "rb") as fd:
+        df = pickle.load(fd)
+
+    expected = DataFrame(index=[], columns=[])
+    tm.assert_frame_equal(df, expected)
+
+
+def test_pickle_pos_args_deprecation():
+    # GH-54229
+    df = DataFrame({"a": [1, 2, 3]})
+    msg = (
+        r"Starting with pandas version 3.0 all arguments of to_pickle except for the "
+        r"argument 'path' will be keyword-only."
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        buffer = io.BytesIO()
+        df.to_pickle(buffer, "infer")

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

@@ -0,0 +1,43 @@
+from io import BytesIO
+
+import pytest
+
+from pandas import read_csv
+
+
+def test_streaming_s3_objects():
+    # GH17135
+    # botocore gained iteration support in 1.10.47, can now be used in read_*
+    pytest.importorskip("botocore", minversion="1.10.47")
+    from botocore.response import StreamingBody
+
+    data = [b"foo,bar,baz\n1,2,3\n4,5,6\n", b"just,the,header\n"]
+    for el in data:
+        body = StreamingBody(BytesIO(el), content_length=len(el))
+        read_csv(body)
+
+
+@pytest.mark.single_cpu
+def test_read_without_creds_from_pub_bucket(s3_public_bucket_with_data, s3so):
+    # GH 34626
+    pytest.importorskip("s3fs")
+    result = read_csv(
+        f"s3://{s3_public_bucket_with_data.name}/tips.csv",
+        nrows=3,
+        storage_options=s3so,
+    )
+    assert len(result) == 3
+
+
+@pytest.mark.single_cpu
+def test_read_with_creds_from_pub_bucket(s3_public_bucket_with_data, s3so):
+    # Ensure we can read from a public bucket with credentials
+    # GH 34626
+    pytest.importorskip("s3fs")
+    df = read_csv(
+        f"s3://{s3_public_bucket_with_data.name}/tips.csv",
+        nrows=5,
+        header=None,
+        storage_options=s3so,
+    )
+    assert len(df) == 5

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

@@ -0,0 +1,164 @@
+import datetime
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.util.version import Version
+
+pyreadstat = pytest.importorskip("pyreadstat")
+
+
+# TODO(CoW) - detection of chained assignment in cython
+# https://github.com/pandas-dev/pandas/issues/51315
+@pytest.mark.filterwarnings("ignore::pandas.errors.ChainedAssignmentError")
+@pytest.mark.filterwarnings("ignore:ChainedAssignmentError:FutureWarning")
+@pytest.mark.parametrize("path_klass", [lambda p: p, Path])
+def test_spss_labelled_num(path_klass, datapath):
+    # test file from the Haven project (https://haven.tidyverse.org/)
+    # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
+    fname = path_klass(datapath("io", "data", "spss", "labelled-num.sav"))
+
+    df = pd.read_spss(fname, convert_categoricals=True)
+    expected = pd.DataFrame({"VAR00002": "This is one"}, index=[0])
+    expected["VAR00002"] = pd.Categorical(expected["VAR00002"])
+    tm.assert_frame_equal(df, expected)
+
+    df = pd.read_spss(fname, convert_categoricals=False)
+    expected = pd.DataFrame({"VAR00002": 1.0}, index=[0])
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.filterwarnings("ignore::pandas.errors.ChainedAssignmentError")
+@pytest.mark.filterwarnings("ignore:ChainedAssignmentError:FutureWarning")
+def test_spss_labelled_num_na(datapath):
+    # test file from the Haven project (https://haven.tidyverse.org/)
+    # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
+    fname = datapath("io", "data", "spss", "labelled-num-na.sav")
+
+    df = pd.read_spss(fname, convert_categoricals=True)
+    expected = pd.DataFrame({"VAR00002": ["This is one", None]})
+    expected["VAR00002"] = pd.Categorical(expected["VAR00002"])
+    tm.assert_frame_equal(df, expected)
+
+    df = pd.read_spss(fname, convert_categoricals=False)
+    expected = pd.DataFrame({"VAR00002": [1.0, np.nan]})
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.filterwarnings("ignore::pandas.errors.ChainedAssignmentError")
+@pytest.mark.filterwarnings("ignore:ChainedAssignmentError:FutureWarning")
+def test_spss_labelled_str(datapath):
+    # test file from the Haven project (https://haven.tidyverse.org/)
+    # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
+    fname = datapath("io", "data", "spss", "labelled-str.sav")
+
+    df = pd.read_spss(fname, convert_categoricals=True)
+    expected = pd.DataFrame({"gender": ["Male", "Female"]})
+    expected["gender"] = pd.Categorical(expected["gender"])
+    tm.assert_frame_equal(df, expected)
+
+    df = pd.read_spss(fname, convert_categoricals=False)
+    expected = pd.DataFrame({"gender": ["M", "F"]})
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.filterwarnings("ignore::pandas.errors.ChainedAssignmentError")
+@pytest.mark.filterwarnings("ignore:ChainedAssignmentError:FutureWarning")
+def test_spss_umlauts(datapath):
+    # test file from the Haven project (https://haven.tidyverse.org/)
+    # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
+    fname = datapath("io", "data", "spss", "umlauts.sav")
+
+    df = pd.read_spss(fname, convert_categoricals=True)
+    expected = pd.DataFrame(
+        {"var1": ["the ä umlaut", "the ü umlaut", "the ä umlaut", "the ö umlaut"]}
+    )
+    expected["var1"] = pd.Categorical(expected["var1"])
+    tm.assert_frame_equal(df, expected)
+
+    df = pd.read_spss(fname, convert_categoricals=False)
+    expected = pd.DataFrame({"var1": [1.0, 2.0, 1.0, 3.0]})
+    tm.assert_frame_equal(df, expected)
+
+
+def test_spss_usecols(datapath):
+    # usecols must be list-like
+    fname = datapath("io", "data", "spss", "labelled-num.sav")
+
+    with pytest.raises(TypeError, match="usecols must be list-like."):
+        pd.read_spss(fname, usecols="VAR00002")
+
+
+def test_spss_umlauts_dtype_backend(datapath, dtype_backend):
+    # test file from the Haven project (https://haven.tidyverse.org/)
+    # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
+    fname = datapath("io", "data", "spss", "umlauts.sav")
+
+    df = pd.read_spss(fname, convert_categoricals=False, dtype_backend=dtype_backend)
+    expected = pd.DataFrame({"var1": [1.0, 2.0, 1.0, 3.0]}, dtype="Int64")
+
+    if dtype_backend == "pyarrow":
+        pa = pytest.importorskip("pyarrow")
+
+        from pandas.arrays import ArrowExtensionArray
+
+        expected = pd.DataFrame(
+            {
+                col: ArrowExtensionArray(pa.array(expected[col], from_pandas=True))
+                for col in expected.columns
+            }
+        )
+
+    tm.assert_frame_equal(df, expected)
+
+
+def test_invalid_dtype_backend():
+    msg = (
+        "dtype_backend numpy is invalid, only 'numpy_nullable' and "
+        "'pyarrow' are allowed."
+    )
+    with pytest.raises(ValueError, match=msg):
+        pd.read_spss("test", dtype_backend="numpy")
+
+
+@pytest.mark.filterwarnings("ignore::pandas.errors.ChainedAssignmentError")
+@pytest.mark.filterwarnings("ignore:ChainedAssignmentError:FutureWarning")
+def test_spss_metadata(datapath):
+    # GH 54264
+    fname = datapath("io", "data", "spss", "labelled-num.sav")
+
+    df = pd.read_spss(fname)
+    metadata = {
+        "column_names": ["VAR00002"],
+        "column_labels": [None],
+        "column_names_to_labels": {"VAR00002": None},
+        "file_encoding": "UTF-8",
+        "number_columns": 1,
+        "number_rows": 1,
+        "variable_value_labels": {"VAR00002": {1.0: "This is one"}},
+        "value_labels": {"labels0": {1.0: "This is one"}},
+        "variable_to_label": {"VAR00002": "labels0"},
+        "notes": [],
+        "original_variable_types": {"VAR00002": "F8.0"},
+        "readstat_variable_types": {"VAR00002": "double"},
+        "table_name": None,
+        "missing_ranges": {},
+        "missing_user_values": {},
+        "variable_storage_width": {"VAR00002": 8},
+        "variable_display_width": {"VAR00002": 8},
+        "variable_alignment": {"VAR00002": "unknown"},
+        "variable_measure": {"VAR00002": "unknown"},
+        "file_label": None,
+        "file_format": "sav/zsav",
+    }
+    if Version(pyreadstat.__version__) >= Version("1.2.4"):
+        metadata.update(
+            {
+                "creation_time": datetime.datetime(2015, 2, 6, 14, 33, 36),
+                "modification_time": datetime.datetime(2015, 2, 6, 14, 33, 36),
+            }
+        )
+    assert df.attrs == metadata

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

@@ -0,0 +1,2381 @@
+import bz2
+import datetime as dt
+from datetime import datetime
+import gzip
+import io
+import os
+import struct
+import tarfile
+import zipfile
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import CategoricalDtype
+import pandas._testing as tm
+from pandas.core.frame import (
+    DataFrame,
+    Series,
+)
+
+from pandas.io.parsers import read_csv
+from pandas.io.stata import (
+    CategoricalConversionWarning,
+    InvalidColumnName,
+    PossiblePrecisionLoss,
+    StataMissingValue,
+    StataReader,
+    StataWriter,
+    StataWriterUTF8,
+    ValueLabelTypeMismatch,
+    read_stata,
+)
+
+
+@pytest.fixture
+def mixed_frame():
+    return DataFrame(
+        {
+            "a": [1, 2, 3, 4],
+            "b": [1.0, 3.0, 27.0, 81.0],
+            "c": ["Atlanta", "Birmingham", "Cincinnati", "Detroit"],
+        }
+    )
+
+
+@pytest.fixture
+def parsed_114(datapath):
+    dta14_114 = datapath("io", "data", "stata", "stata5_114.dta")
+    parsed_114 = read_stata(dta14_114, convert_dates=True)
+    parsed_114.index.name = "index"
+    return parsed_114
+
+
+class TestStata:
+    def read_dta(self, file):
+        # Legacy default reader configuration
+        return read_stata(file, convert_dates=True)
+
+    def read_csv(self, file):
+        return read_csv(file, parse_dates=True)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_read_empty_dta(self, version):
+        empty_ds = DataFrame(columns=["unit"])
+        # GH 7369, make sure can read a 0-obs dta file
+        with tm.ensure_clean() as path:
+            empty_ds.to_stata(path, write_index=False, version=version)
+            empty_ds2 = read_stata(path)
+            tm.assert_frame_equal(empty_ds, empty_ds2)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_read_empty_dta_with_dtypes(self, version):
+        # GH 46240
+        # Fixing above bug revealed that types are not correctly preserved when
+        # writing empty DataFrames
+        empty_df_typed = DataFrame(
+            {
+                "i8": np.array([0], dtype=np.int8),
+                "i16": np.array([0], dtype=np.int16),
+                "i32": np.array([0], dtype=np.int32),
+                "i64": np.array([0], dtype=np.int64),
+                "u8": np.array([0], dtype=np.uint8),
+                "u16": np.array([0], dtype=np.uint16),
+                "u32": np.array([0], dtype=np.uint32),
+                "u64": np.array([0], dtype=np.uint64),
+                "f32": np.array([0], dtype=np.float32),
+                "f64": np.array([0], dtype=np.float64),
+            }
+        )
+        expected = empty_df_typed.copy()
+        # No uint# support. Downcast since values in range for int#
+        expected["u8"] = expected["u8"].astype(np.int8)
+        expected["u16"] = expected["u16"].astype(np.int16)
+        expected["u32"] = expected["u32"].astype(np.int32)
+        # No int64 supported at all. Downcast since values in range for int32
+        expected["u64"] = expected["u64"].astype(np.int32)
+        expected["i64"] = expected["i64"].astype(np.int32)
+
+        # GH 7369, make sure can read a 0-obs dta file
+        with tm.ensure_clean() as path:
+            empty_df_typed.to_stata(path, write_index=False, version=version)
+            empty_reread = read_stata(path)
+            tm.assert_frame_equal(expected, empty_reread)
+            tm.assert_series_equal(expected.dtypes, empty_reread.dtypes)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_read_index_col_none(self, version):
+        df = DataFrame({"a": range(5), "b": ["b1", "b2", "b3", "b4", "b5"]})
+        # GH 7369, make sure can read a 0-obs dta file
+        with tm.ensure_clean() as path:
+            df.to_stata(path, write_index=False, version=version)
+            read_df = read_stata(path)
+
+        assert isinstance(read_df.index, pd.RangeIndex)
+        expected = df.copy()
+        expected["a"] = expected["a"].astype(np.int32)
+        tm.assert_frame_equal(read_df, expected, check_index_type=True)
+
+    @pytest.mark.parametrize("file", ["stata1_114", "stata1_117"])
+    def test_read_dta1(self, file, datapath):
+        file = datapath("io", "data", "stata", f"{file}.dta")
+        parsed = self.read_dta(file)
+
+        # Pandas uses np.nan as missing value.
+        # Thus, all columns will be of type float, regardless of their name.
+        expected = DataFrame(
+            [(np.nan, np.nan, np.nan, np.nan, np.nan)],
+            columns=["float_miss", "double_miss", "byte_miss", "int_miss", "long_miss"],
+        )
+
+        # this is an oddity as really the nan should be float64, but
+        # the casting doesn't fail so need to match stata here
+        expected["float_miss"] = expected["float_miss"].astype(np.float32)
+
+        tm.assert_frame_equal(parsed, expected)
+
+    def test_read_dta2(self, datapath):
+        expected = DataFrame.from_records(
+            [
+                (
+                    datetime(2006, 11, 19, 23, 13, 20),
+                    1479596223000,
+                    datetime(2010, 1, 20),
+                    datetime(2010, 1, 8),
+                    datetime(2010, 1, 1),
+                    datetime(1974, 7, 1),
+                    datetime(2010, 1, 1),
+                    datetime(2010, 1, 1),
+                ),
+                (
+                    datetime(1959, 12, 31, 20, 3, 20),
+                    -1479590,
+                    datetime(1953, 10, 2),
+                    datetime(1948, 6, 10),
+                    datetime(1955, 1, 1),
+                    datetime(1955, 7, 1),
+                    datetime(1955, 1, 1),
+                    datetime(2, 1, 1),
+                ),
+                (pd.NaT, pd.NaT, pd.NaT, pd.NaT, pd.NaT, pd.NaT, pd.NaT, pd.NaT),
+            ],
+            columns=[
+                "datetime_c",
+                "datetime_big_c",
+                "date",
+                "weekly_date",
+                "monthly_date",
+                "quarterly_date",
+                "half_yearly_date",
+                "yearly_date",
+            ],
+        )
+        expected["yearly_date"] = expected["yearly_date"].astype("O")
+
+        path1 = datapath("io", "data", "stata", "stata2_114.dta")
+        path2 = datapath("io", "data", "stata", "stata2_115.dta")
+        path3 = datapath("io", "data", "stata", "stata2_117.dta")
+
+        with tm.assert_produces_warning(UserWarning):
+            parsed_114 = self.read_dta(path1)
+        with tm.assert_produces_warning(UserWarning):
+            parsed_115 = self.read_dta(path2)
+        with tm.assert_produces_warning(UserWarning):
+            parsed_117 = self.read_dta(path3)
+            # FIXME: don't leave commented-out
+            # 113 is buggy due to limits of date format support in Stata
+            # parsed_113 = self.read_dta(
+            # datapath("io", "data", "stata", "stata2_113.dta")
+            # )
+
+        # FIXME: don't leave commented-out
+        # buggy test because of the NaT comparison on certain platforms
+        # Format 113 test fails since it does not support tc and tC formats
+        # tm.assert_frame_equal(parsed_113, expected)
+        tm.assert_frame_equal(parsed_114, expected, check_datetimelike_compat=True)
+        tm.assert_frame_equal(parsed_115, expected, check_datetimelike_compat=True)
+        tm.assert_frame_equal(parsed_117, expected, check_datetimelike_compat=True)
+
+    @pytest.mark.parametrize(
+        "file", ["stata3_113", "stata3_114", "stata3_115", "stata3_117"]
+    )
+    def test_read_dta3(self, file, datapath):
+        file = datapath("io", "data", "stata", f"{file}.dta")
+        parsed = self.read_dta(file)
+
+        # match stata here
+        expected = self.read_csv(datapath("io", "data", "stata", "stata3.csv"))
+        expected = expected.astype(np.float32)
+        expected["year"] = expected["year"].astype(np.int16)
+        expected["quarter"] = expected["quarter"].astype(np.int8)
+
+        tm.assert_frame_equal(parsed, expected)
+
+    @pytest.mark.parametrize(
+        "file", ["stata4_113", "stata4_114", "stata4_115", "stata4_117"]
+    )
+    def test_read_dta4(self, file, datapath):
+        file = datapath("io", "data", "stata", f"{file}.dta")
+        parsed = self.read_dta(file)
+
+        expected = DataFrame.from_records(
+            [
+                ["one", "ten", "one", "one", "one"],
+                ["two", "nine", "two", "two", "two"],
+                ["three", "eight", "three", "three", "three"],
+                ["four", "seven", 4, "four", "four"],
+                ["five", "six", 5, np.nan, "five"],
+                ["six", "five", 6, np.nan, "six"],
+                ["seven", "four", 7, np.nan, "seven"],
+                ["eight", "three", 8, np.nan, "eight"],
+                ["nine", "two", 9, np.nan, "nine"],
+                ["ten", "one", "ten", np.nan, "ten"],
+            ],
+            columns=[
+                "fully_labeled",
+                "fully_labeled2",
+                "incompletely_labeled",
+                "labeled_with_missings",
+                "float_labelled",
+            ],
+        )
+
+        # these are all categoricals
+        for col in expected:
+            orig = expected[col].copy()
+
+            categories = np.asarray(expected["fully_labeled"][orig.notna()])
+            if col == "incompletely_labeled":
+                categories = orig
+
+            cat = orig.astype("category")._values
+            cat = cat.set_categories(categories, ordered=True)
+            cat.categories.rename(None, inplace=True)
+
+            expected[col] = cat
+
+        # stata doesn't save .category metadata
+        tm.assert_frame_equal(parsed, expected)
+
+    # File containing strls
+    def test_read_dta12(self, datapath):
+        parsed_117 = self.read_dta(datapath("io", "data", "stata", "stata12_117.dta"))
+        expected = DataFrame.from_records(
+            [
+                [1, "abc", "abcdefghi"],
+                [3, "cba", "qwertywertyqwerty"],
+                [93, "", "strl"],
+            ],
+            columns=["x", "y", "z"],
+        )
+
+        tm.assert_frame_equal(parsed_117, expected, check_dtype=False)
+
+    def test_read_dta18(self, datapath):
+        parsed_118 = self.read_dta(datapath("io", "data", "stata", "stata14_118.dta"))
+        parsed_118["Bytes"] = parsed_118["Bytes"].astype("O")
+        expected = DataFrame.from_records(
+            [
+                ["Cat", "Bogota", "Bogotá", 1, 1.0, "option b Ünicode", 1.0],
+                ["Dog", "Boston", "Uzunköprü", np.nan, np.nan, np.nan, np.nan],
+                ["Plane", "Rome", "Tromsø", 0, 0.0, "option a", 0.0],
+                ["Potato", "Tokyo", "Elâzığ", -4, 4.0, 4, 4],  # noqa: RUF001
+                ["", "", "", 0, 0.3332999, "option a", 1 / 3.0],
+            ],
+            columns=[
+                "Things",
+                "Cities",
+                "Unicode_Cities_Strl",
+                "Ints",
+                "Floats",
+                "Bytes",
+                "Longs",
+            ],
+        )
+        expected["Floats"] = expected["Floats"].astype(np.float32)
+        for col in parsed_118.columns:
+            tm.assert_almost_equal(parsed_118[col], expected[col])
+
+        with StataReader(datapath("io", "data", "stata", "stata14_118.dta")) as rdr:
+            vl = rdr.variable_labels()
+            vl_expected = {
+                "Unicode_Cities_Strl": "Here are some strls with Ünicode chars",
+                "Longs": "long data",
+                "Things": "Here are some things",
+                "Bytes": "byte data",
+                "Ints": "int data",
+                "Cities": "Here are some cities",
+                "Floats": "float data",
+            }
+            tm.assert_dict_equal(vl, vl_expected)
+
+            assert rdr.data_label == "This is a  Ünicode data label"
+
+    def test_read_write_dta5(self):
+        original = DataFrame(
+            [(np.nan, np.nan, np.nan, np.nan, np.nan)],
+            columns=["float_miss", "double_miss", "byte_miss", "int_miss", "long_miss"],
+        )
+        original.index.name = "index"
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path, convert_dates=None)
+            written_and_read_again = self.read_dta(path)
+
+        expected = original.copy()
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
+    def test_write_dta6(self, datapath):
+        original = self.read_csv(datapath("io", "data", "stata", "stata3.csv"))
+        original.index.name = "index"
+        original.index = original.index.astype(np.int32)
+        original["year"] = original["year"].astype(np.int32)
+        original["quarter"] = original["quarter"].astype(np.int32)
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path, convert_dates=None)
+            written_and_read_again = self.read_dta(path)
+            tm.assert_frame_equal(
+                written_and_read_again.set_index("index"),
+                original,
+                check_index_type=False,
+            )
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_read_write_dta10(self, version):
+        original = DataFrame(
+            data=[["string", "object", 1, 1.1, np.datetime64("2003-12-25")]],
+            columns=["string", "object", "integer", "floating", "datetime"],
+        )
+        original["object"] = Series(original["object"], dtype=object)
+        original.index.name = "index"
+        original.index = original.index.astype(np.int32)
+        original["integer"] = original["integer"].astype(np.int32)
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path, convert_dates={"datetime": "tc"}, version=version)
+            written_and_read_again = self.read_dta(path)
+            # original.index is np.int32, read index is np.int64
+            tm.assert_frame_equal(
+                written_and_read_again.set_index("index"),
+                original,
+                check_index_type=False,
+            )
+
+    def test_stata_doc_examples(self):
+        with tm.ensure_clean() as path:
+            df = DataFrame(
+                np.random.default_rng(2).standard_normal((10, 2)), columns=list("AB")
+            )
+            df.to_stata(path)
+
+    def test_write_preserves_original(self):
+        # 9795
+
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((5, 4)), columns=list("abcd")
+        )
+        df.loc[2, "a":"c"] = np.nan
+        df_copy = df.copy()
+        with tm.ensure_clean() as path:
+            df.to_stata(path, write_index=False)
+        tm.assert_frame_equal(df, df_copy)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_encoding(self, version, datapath):
+        # GH 4626, proper encoding handling
+        raw = read_stata(datapath("io", "data", "stata", "stata1_encoding.dta"))
+        encoded = read_stata(datapath("io", "data", "stata", "stata1_encoding.dta"))
+        result = encoded.kreis1849[0]
+
+        expected = raw.kreis1849[0]
+        assert result == expected
+        assert isinstance(result, str)
+
+        with tm.ensure_clean() as path:
+            encoded.to_stata(path, write_index=False, version=version)
+            reread_encoded = read_stata(path)
+            tm.assert_frame_equal(encoded, reread_encoded)
+
+    def test_read_write_dta11(self):
+        original = DataFrame(
+            [(1, 2, 3, 4)],
+            columns=[
+                "good",
+                "b\u00E4d",
+                "8number",
+                "astringwithmorethan32characters______",
+            ],
+        )
+        formatted = DataFrame(
+            [(1, 2, 3, 4)],
+            columns=["good", "b_d", "_8number", "astringwithmorethan32characters_"],
+        )
+        formatted.index.name = "index"
+        formatted = formatted.astype(np.int32)
+
+        with tm.ensure_clean() as path:
+            with tm.assert_produces_warning(InvalidColumnName):
+                original.to_stata(path, convert_dates=None)
+
+            written_and_read_again = self.read_dta(path)
+
+        expected = formatted.copy()
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_read_write_dta12(self, version):
+        original = DataFrame(
+            [(1, 2, 3, 4, 5, 6)],
+            columns=[
+                "astringwithmorethan32characters_1",
+                "astringwithmorethan32characters_2",
+                "+",
+                "-",
+                "short",
+                "delete",
+            ],
+        )
+        formatted = DataFrame(
+            [(1, 2, 3, 4, 5, 6)],
+            columns=[
+                "astringwithmorethan32characters_",
+                "_0astringwithmorethan32character",
+                "_",
+                "_1_",
+                "_short",
+                "_delete",
+            ],
+        )
+        formatted.index.name = "index"
+        formatted = formatted.astype(np.int32)
+
+        with tm.ensure_clean() as path:
+            with tm.assert_produces_warning(InvalidColumnName):
+                original.to_stata(path, convert_dates=None, version=version)
+                # should get a warning for that format.
+
+            written_and_read_again = self.read_dta(path)
+
+        expected = formatted.copy()
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
+    def test_read_write_dta13(self):
+        s1 = Series(2**9, dtype=np.int16)
+        s2 = Series(2**17, dtype=np.int32)
+        s3 = Series(2**33, dtype=np.int64)
+        original = DataFrame({"int16": s1, "int32": s2, "int64": s3})
+        original.index.name = "index"
+
+        formatted = original
+        formatted["int64"] = formatted["int64"].astype(np.float64)
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path)
+            written_and_read_again = self.read_dta(path)
+
+        expected = formatted.copy()
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    @pytest.mark.parametrize(
+        "file", ["stata5_113", "stata5_114", "stata5_115", "stata5_117"]
+    )
+    def test_read_write_reread_dta14(self, file, parsed_114, version, datapath):
+        file = datapath("io", "data", "stata", f"{file}.dta")
+        parsed = self.read_dta(file)
+        parsed.index.name = "index"
+
+        tm.assert_frame_equal(parsed_114, parsed)
+
+        with tm.ensure_clean() as path:
+            parsed_114.to_stata(path, convert_dates={"date_td": "td"}, version=version)
+            written_and_read_again = self.read_dta(path)
+
+        expected = parsed_114.copy()
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
+    @pytest.mark.parametrize(
+        "file", ["stata6_113", "stata6_114", "stata6_115", "stata6_117"]
+    )
+    def test_read_write_reread_dta15(self, file, datapath):
+        expected = self.read_csv(datapath("io", "data", "stata", "stata6.csv"))
+        expected["byte_"] = expected["byte_"].astype(np.int8)
+        expected["int_"] = expected["int_"].astype(np.int16)
+        expected["long_"] = expected["long_"].astype(np.int32)
+        expected["float_"] = expected["float_"].astype(np.float32)
+        expected["double_"] = expected["double_"].astype(np.float64)
+        expected["date_td"] = expected["date_td"].apply(
+            datetime.strptime, args=("%Y-%m-%d",)
+        )
+
+        file = datapath("io", "data", "stata", f"{file}.dta")
+        parsed = self.read_dta(file)
+
+        tm.assert_frame_equal(expected, parsed)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_timestamp_and_label(self, version):
+        original = DataFrame([(1,)], columns=["variable"])
+        time_stamp = datetime(2000, 2, 29, 14, 21)
+        data_label = "This is a data file."
+        with tm.ensure_clean() as path:
+            original.to_stata(
+                path, time_stamp=time_stamp, data_label=data_label, version=version
+            )
+
+            with StataReader(path) as reader:
+                assert reader.time_stamp == "29 Feb 2000 14:21"
+                assert reader.data_label == data_label
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_invalid_timestamp(self, version):
+        original = DataFrame([(1,)], columns=["variable"])
+        time_stamp = "01 Jan 2000, 00:00:00"
+        with tm.ensure_clean() as path:
+            msg = "time_stamp should be datetime type"
+            with pytest.raises(ValueError, match=msg):
+                original.to_stata(path, time_stamp=time_stamp, version=version)
+            assert not os.path.isfile(path)
+
+    def test_numeric_column_names(self):
+        original = DataFrame(np.reshape(np.arange(25.0), (5, 5)))
+        original.index.name = "index"
+        with tm.ensure_clean() as path:
+            # should get a warning for that format.
+            with tm.assert_produces_warning(InvalidColumnName):
+                original.to_stata(path)
+
+            written_and_read_again = self.read_dta(path)
+
+        written_and_read_again = written_and_read_again.set_index("index")
+        columns = list(written_and_read_again.columns)
+        convert_col_name = lambda x: int(x[1])
+        written_and_read_again.columns = map(convert_col_name, columns)
+
+        expected = original.copy()
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(expected, written_and_read_again)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_nan_to_missing_value(self, version):
+        s1 = Series(np.arange(4.0), dtype=np.float32)
+        s2 = Series(np.arange(4.0), dtype=np.float64)
+        s1[::2] = np.nan
+        s2[1::2] = np.nan
+        original = DataFrame({"s1": s1, "s2": s2})
+        original.index.name = "index"
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path, version=version)
+            written_and_read_again = self.read_dta(path)
+
+        written_and_read_again = written_and_read_again.set_index("index")
+        expected = original.copy()
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(written_and_read_again, expected)
+
+    def test_no_index(self):
+        columns = ["x", "y"]
+        original = DataFrame(np.reshape(np.arange(10.0), (5, 2)), columns=columns)
+        original.index.name = "index_not_written"
+        with tm.ensure_clean() as path:
+            original.to_stata(path, write_index=False)
+            written_and_read_again = self.read_dta(path)
+            with pytest.raises(KeyError, match=original.index.name):
+                written_and_read_again["index_not_written"]
+
+    def test_string_no_dates(self):
+        s1 = Series(["a", "A longer string"])
+        s2 = Series([1.0, 2.0], dtype=np.float64)
+        original = DataFrame({"s1": s1, "s2": s2})
+        original.index.name = "index"
+        with tm.ensure_clean() as path:
+            original.to_stata(path)
+            written_and_read_again = self.read_dta(path)
+
+        expected = original.copy()
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
+    def test_large_value_conversion(self):
+        s0 = Series([1, 99], dtype=np.int8)
+        s1 = Series([1, 127], dtype=np.int8)
+        s2 = Series([1, 2**15 - 1], dtype=np.int16)
+        s3 = Series([1, 2**63 - 1], dtype=np.int64)
+        original = DataFrame({"s0": s0, "s1": s1, "s2": s2, "s3": s3})
+        original.index.name = "index"
+        with tm.ensure_clean() as path:
+            with tm.assert_produces_warning(PossiblePrecisionLoss):
+                original.to_stata(path)
+
+            written_and_read_again = self.read_dta(path)
+
+        modified = original.copy()
+        modified["s1"] = Series(modified["s1"], dtype=np.int16)
+        modified["s2"] = Series(modified["s2"], dtype=np.int32)
+        modified["s3"] = Series(modified["s3"], dtype=np.float64)
+        modified.index = original.index.astype(np.int32)
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), modified)
+
+    def test_dates_invalid_column(self):
+        original = DataFrame([datetime(2006, 11, 19, 23, 13, 20)])
+        original.index.name = "index"
+        with tm.ensure_clean() as path:
+            with tm.assert_produces_warning(InvalidColumnName):
+                original.to_stata(path, convert_dates={0: "tc"})
+
+            written_and_read_again = self.read_dta(path)
+
+        modified = original.copy()
+        modified.columns = ["_0"]
+        modified.index = original.index.astype(np.int32)
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), modified)
+
+    def test_105(self, datapath):
+        # Data obtained from:
+        # http://go.worldbank.org/ZXY29PVJ21
+        dpath = datapath("io", "data", "stata", "S4_EDUC1.dta")
+        df = read_stata(dpath)
+        df0 = [[1, 1, 3, -2], [2, 1, 2, -2], [4, 1, 1, -2]]
+        df0 = DataFrame(df0)
+        df0.columns = ["clustnum", "pri_schl", "psch_num", "psch_dis"]
+        df0["clustnum"] = df0["clustnum"].astype(np.int16)
+        df0["pri_schl"] = df0["pri_schl"].astype(np.int8)
+        df0["psch_num"] = df0["psch_num"].astype(np.int8)
+        df0["psch_dis"] = df0["psch_dis"].astype(np.float32)
+        tm.assert_frame_equal(df.head(3), df0)
+
+    def test_value_labels_old_format(self, datapath):
+        # GH 19417
+        #
+        # Test that value_labels() returns an empty dict if the file format
+        # predates supporting value labels.
+        dpath = datapath("io", "data", "stata", "S4_EDUC1.dta")
+        with StataReader(dpath) as reader:
+            assert reader.value_labels() == {}
+
+    def test_date_export_formats(self):
+        columns = ["tc", "td", "tw", "tm", "tq", "th", "ty"]
+        conversions = {c: c for c in columns}
+        data = [datetime(2006, 11, 20, 23, 13, 20)] * len(columns)
+        original = DataFrame([data], columns=columns)
+        original.index.name = "index"
+        expected_values = [
+            datetime(2006, 11, 20, 23, 13, 20),  # Time
+            datetime(2006, 11, 20),  # Day
+            datetime(2006, 11, 19),  # Week
+            datetime(2006, 11, 1),  # Month
+            datetime(2006, 10, 1),  # Quarter year
+            datetime(2006, 7, 1),  # Half year
+            datetime(2006, 1, 1),
+        ]  # Year
+
+        expected = DataFrame(
+            [expected_values],
+            index=pd.Index([0], dtype=np.int32, name="index"),
+            columns=columns,
+        )
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path, convert_dates=conversions)
+            written_and_read_again = self.read_dta(path)
+
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
+    def test_write_missing_strings(self):
+        original = DataFrame([["1"], [None]], columns=["foo"])
+
+        expected = DataFrame(
+            [["1"], [""]],
+            index=pd.Index([0, 1], dtype=np.int32, name="index"),
+            columns=["foo"],
+        )
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path)
+            written_and_read_again = self.read_dta(path)
+
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    @pytest.mark.parametrize("byteorder", [">", "<"])
+    def test_bool_uint(self, byteorder, version):
+        s0 = Series([0, 1, True], dtype=np.bool_)
+        s1 = Series([0, 1, 100], dtype=np.uint8)
+        s2 = Series([0, 1, 255], dtype=np.uint8)
+        s3 = Series([0, 1, 2**15 - 100], dtype=np.uint16)
+        s4 = Series([0, 1, 2**16 - 1], dtype=np.uint16)
+        s5 = Series([0, 1, 2**31 - 100], dtype=np.uint32)
+        s6 = Series([0, 1, 2**32 - 1], dtype=np.uint32)
+
+        original = DataFrame(
+            {"s0": s0, "s1": s1, "s2": s2, "s3": s3, "s4": s4, "s5": s5, "s6": s6}
+        )
+        original.index.name = "index"
+        expected = original.copy()
+        expected.index = original.index.astype(np.int32)
+        expected_types = (
+            np.int8,
+            np.int8,
+            np.int16,
+            np.int16,
+            np.int32,
+            np.int32,
+            np.float64,
+        )
+        for c, t in zip(expected.columns, expected_types):
+            expected[c] = expected[c].astype(t)
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path, byteorder=byteorder, version=version)
+            written_and_read_again = self.read_dta(path)
+
+        written_and_read_again = written_and_read_again.set_index("index")
+        tm.assert_frame_equal(written_and_read_again, expected)
+
+    def test_variable_labels(self, datapath):
+        with StataReader(datapath("io", "data", "stata", "stata7_115.dta")) as rdr:
+            sr_115 = rdr.variable_labels()
+        with StataReader(datapath("io", "data", "stata", "stata7_117.dta")) as rdr:
+            sr_117 = rdr.variable_labels()
+        keys = ("var1", "var2", "var3")
+        labels = ("label1", "label2", "label3")
+        for k, v in sr_115.items():
+            assert k in sr_117
+            assert v == sr_117[k]
+            assert k in keys
+            assert v in labels
+
+    def test_minimal_size_col(self):
+        str_lens = (1, 100, 244)
+        s = {}
+        for str_len in str_lens:
+            s["s" + str(str_len)] = Series(
+                ["a" * str_len, "b" * str_len, "c" * str_len]
+            )
+        original = DataFrame(s)
+        with tm.ensure_clean() as path:
+            original.to_stata(path, write_index=False)
+
+            with StataReader(path) as sr:
+                sr._ensure_open()  # The `_*list` variables are initialized here
+                for variable, fmt, typ in zip(sr._varlist, sr._fmtlist, sr._typlist):
+                    assert int(variable[1:]) == int(fmt[1:-1])
+                    assert int(variable[1:]) == typ
+
+    def test_excessively_long_string(self):
+        str_lens = (1, 244, 500)
+        s = {}
+        for str_len in str_lens:
+            s["s" + str(str_len)] = Series(
+                ["a" * str_len, "b" * str_len, "c" * str_len]
+            )
+        original = DataFrame(s)
+        msg = (
+            r"Fixed width strings in Stata \.dta files are limited to 244 "
+            r"\(or fewer\)\ncharacters\.  Column 's500' does not satisfy "
+            r"this restriction\. Use the\n'version=117' parameter to write "
+            r"the newer \(Stata 13 and later\) format\."
+        )
+        with pytest.raises(ValueError, match=msg):
+            with tm.ensure_clean() as path:
+                original.to_stata(path)
+
+    def test_missing_value_generator(self):
+        types = ("b", "h", "l")
+        df = DataFrame([[0.0]], columns=["float_"])
+        with tm.ensure_clean() as path:
+            df.to_stata(path)
+            with StataReader(path) as rdr:
+                valid_range = rdr.VALID_RANGE
+        expected_values = ["." + chr(97 + i) for i in range(26)]
+        expected_values.insert(0, ".")
+        for t in types:
+            offset = valid_range[t][1]
+            for i in range(27):
+                val = StataMissingValue(offset + 1 + i)
+                assert val.string == expected_values[i]
+
+        # Test extremes for floats
+        val = StataMissingValue(struct.unpack("<f", b"\x00\x00\x00\x7f")[0])
+        assert val.string == "."
+        val = StataMissingValue(struct.unpack("<f", b"\x00\xd0\x00\x7f")[0])
+        assert val.string == ".z"
+
+        # Test extremes for floats
+        val = StataMissingValue(
+            struct.unpack("<d", b"\x00\x00\x00\x00\x00\x00\xe0\x7f")[0]
+        )
+        assert val.string == "."
+        val = StataMissingValue(
+            struct.unpack("<d", b"\x00\x00\x00\x00\x00\x1a\xe0\x7f")[0]
+        )
+        assert val.string == ".z"
+
+    @pytest.mark.parametrize("file", ["stata8_113", "stata8_115", "stata8_117"])
+    def test_missing_value_conversion(self, file, datapath):
+        columns = ["int8_", "int16_", "int32_", "float32_", "float64_"]
+        smv = StataMissingValue(101)
+        keys = sorted(smv.MISSING_VALUES.keys())
+        data = []
+        for i in range(27):
+            row = [StataMissingValue(keys[i + (j * 27)]) for j in range(5)]
+            data.append(row)
+        expected = DataFrame(data, columns=columns)
+
+        parsed = read_stata(
+            datapath("io", "data", "stata", f"{file}.dta"), convert_missing=True
+        )
+        tm.assert_frame_equal(parsed, expected)
+
+    def test_big_dates(self, datapath):
+        yr = [1960, 2000, 9999, 100, 2262, 1677]
+        mo = [1, 1, 12, 1, 4, 9]
+        dd = [1, 1, 31, 1, 22, 23]
+        hr = [0, 0, 23, 0, 0, 0]
+        mm = [0, 0, 59, 0, 0, 0]
+        ss = [0, 0, 59, 0, 0, 0]
+        expected = []
+        for year, month, day, hour, minute, second in zip(yr, mo, dd, hr, mm, ss):
+            row = []
+            for j in range(7):
+                if j == 0:
+                    row.append(datetime(year, month, day, hour, minute, second))
+                elif j == 6:
+                    row.append(datetime(year, 1, 1))
+                else:
+                    row.append(datetime(year, month, day))
+            expected.append(row)
+        expected.append([pd.NaT] * 7)
+        columns = [
+            "date_tc",
+            "date_td",
+            "date_tw",
+            "date_tm",
+            "date_tq",
+            "date_th",
+            "date_ty",
+        ]
+
+        # Fixes for weekly, quarterly,half,year
+        expected[2][2] = datetime(9999, 12, 24)
+        expected[2][3] = datetime(9999, 12, 1)
+        expected[2][4] = datetime(9999, 10, 1)
+        expected[2][5] = datetime(9999, 7, 1)
+        expected[4][2] = datetime(2262, 4, 16)
+        expected[4][3] = expected[4][4] = datetime(2262, 4, 1)
+        expected[4][5] = expected[4][6] = datetime(2262, 1, 1)
+        expected[5][2] = expected[5][3] = expected[5][4] = datetime(1677, 10, 1)
+        expected[5][5] = expected[5][6] = datetime(1678, 1, 1)
+
+        expected = DataFrame(expected, columns=columns, dtype=object)
+        parsed_115 = read_stata(datapath("io", "data", "stata", "stata9_115.dta"))
+        parsed_117 = read_stata(datapath("io", "data", "stata", "stata9_117.dta"))
+        tm.assert_frame_equal(expected, parsed_115, check_datetimelike_compat=True)
+        tm.assert_frame_equal(expected, parsed_117, check_datetimelike_compat=True)
+
+        date_conversion = {c: c[-2:] for c in columns}
+        # {c : c[-2:] for c in columns}
+        with tm.ensure_clean() as path:
+            expected.index.name = "index"
+            expected.to_stata(path, convert_dates=date_conversion)
+            written_and_read_again = self.read_dta(path)
+
+        tm.assert_frame_equal(
+            written_and_read_again.set_index("index"),
+            expected.set_index(expected.index.astype(np.int32)),
+            check_datetimelike_compat=True,
+        )
+
+    def test_dtype_conversion(self, datapath):
+        expected = self.read_csv(datapath("io", "data", "stata", "stata6.csv"))
+        expected["byte_"] = expected["byte_"].astype(np.int8)
+        expected["int_"] = expected["int_"].astype(np.int16)
+        expected["long_"] = expected["long_"].astype(np.int32)
+        expected["float_"] = expected["float_"].astype(np.float32)
+        expected["double_"] = expected["double_"].astype(np.float64)
+        expected["date_td"] = expected["date_td"].apply(
+            datetime.strptime, args=("%Y-%m-%d",)
+        )
+
+        no_conversion = read_stata(
+            datapath("io", "data", "stata", "stata6_117.dta"), convert_dates=True
+        )
+        tm.assert_frame_equal(expected, no_conversion)
+
+        conversion = read_stata(
+            datapath("io", "data", "stata", "stata6_117.dta"),
+            convert_dates=True,
+            preserve_dtypes=False,
+        )
+
+        # read_csv types are the same
+        expected = self.read_csv(datapath("io", "data", "stata", "stata6.csv"))
+        expected["date_td"] = expected["date_td"].apply(
+            datetime.strptime, args=("%Y-%m-%d",)
+        )
+
+        tm.assert_frame_equal(expected, conversion)
+
+    def test_drop_column(self, datapath):
+        expected = self.read_csv(datapath("io", "data", "stata", "stata6.csv"))
+        expected["byte_"] = expected["byte_"].astype(np.int8)
+        expected["int_"] = expected["int_"].astype(np.int16)
+        expected["long_"] = expected["long_"].astype(np.int32)
+        expected["float_"] = expected["float_"].astype(np.float32)
+        expected["double_"] = expected["double_"].astype(np.float64)
+        expected["date_td"] = expected["date_td"].apply(
+            datetime.strptime, args=("%Y-%m-%d",)
+        )
+
+        columns = ["byte_", "int_", "long_"]
+        expected = expected[columns]
+        dropped = read_stata(
+            datapath("io", "data", "stata", "stata6_117.dta"),
+            convert_dates=True,
+            columns=columns,
+        )
+
+        tm.assert_frame_equal(expected, dropped)
+
+        # See PR 10757
+        columns = ["int_", "long_", "byte_"]
+        expected = expected[columns]
+        reordered = read_stata(
+            datapath("io", "data", "stata", "stata6_117.dta"),
+            convert_dates=True,
+            columns=columns,
+        )
+        tm.assert_frame_equal(expected, reordered)
+
+        msg = "columns contains duplicate entries"
+        with pytest.raises(ValueError, match=msg):
+            columns = ["byte_", "byte_"]
+            read_stata(
+                datapath("io", "data", "stata", "stata6_117.dta"),
+                convert_dates=True,
+                columns=columns,
+            )
+
+        msg = "The following columns were not found in the Stata data set: not_found"
+        with pytest.raises(ValueError, match=msg):
+            columns = ["byte_", "int_", "long_", "not_found"]
+            read_stata(
+                datapath("io", "data", "stata", "stata6_117.dta"),
+                convert_dates=True,
+                columns=columns,
+            )
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    @pytest.mark.filterwarnings(
+        "ignore:\\nStata value:pandas.io.stata.ValueLabelTypeMismatch"
+    )
+    def test_categorical_writing(self, version):
+        original = DataFrame.from_records(
+            [
+                ["one", "ten", "one", "one", "one", 1],
+                ["two", "nine", "two", "two", "two", 2],
+                ["three", "eight", "three", "three", "three", 3],
+                ["four", "seven", 4, "four", "four", 4],
+                ["five", "six", 5, np.nan, "five", 5],
+                ["six", "five", 6, np.nan, "six", 6],
+                ["seven", "four", 7, np.nan, "seven", 7],
+                ["eight", "three", 8, np.nan, "eight", 8],
+                ["nine", "two", 9, np.nan, "nine", 9],
+                ["ten", "one", "ten", np.nan, "ten", 10],
+            ],
+            columns=[
+                "fully_labeled",
+                "fully_labeled2",
+                "incompletely_labeled",
+                "labeled_with_missings",
+                "float_labelled",
+                "unlabeled",
+            ],
+        )
+        expected = original.copy()
+
+        # these are all categoricals
+        original = pd.concat(
+            [original[col].astype("category") for col in original], axis=1
+        )
+        expected.index = expected.index.set_names("index").astype(np.int32)
+
+        expected["incompletely_labeled"] = expected["incompletely_labeled"].apply(str)
+        expected["unlabeled"] = expected["unlabeled"].apply(str)
+        for col in expected:
+            orig = expected[col].copy()
+
+            cat = orig.astype("category")._values
+            cat = cat.as_ordered()
+            if col == "unlabeled":
+                cat = cat.set_categories(orig, ordered=True)
+
+            cat.categories.rename(None, inplace=True)
+
+            expected[col] = cat
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path, version=version)
+            written_and_read_again = self.read_dta(path)
+
+        res = written_and_read_again.set_index("index")
+        tm.assert_frame_equal(res, expected)
+
+    def test_categorical_warnings_and_errors(self):
+        # Warning for non-string labels
+        # Error for labels too long
+        original = DataFrame.from_records(
+            [["a" * 10000], ["b" * 10000], ["c" * 10000], ["d" * 10000]],
+            columns=["Too_long"],
+        )
+
+        original = pd.concat(
+            [original[col].astype("category") for col in original], axis=1
+        )
+        with tm.ensure_clean() as path:
+            msg = (
+                "Stata value labels for a single variable must have "
+                r"a combined length less than 32,000 characters\."
+            )
+            with pytest.raises(ValueError, match=msg):
+                original.to_stata(path)
+
+        original = DataFrame.from_records(
+            [["a"], ["b"], ["c"], ["d"], [1]], columns=["Too_long"]
+        )
+        original = pd.concat(
+            [original[col].astype("category") for col in original], axis=1
+        )
+
+        with tm.assert_produces_warning(ValueLabelTypeMismatch):
+            original.to_stata(path)
+            # should get a warning for mixed content
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_categorical_with_stata_missing_values(self, version):
+        values = [["a" + str(i)] for i in range(120)]
+        values.append([np.nan])
+        original = DataFrame.from_records(values, columns=["many_labels"])
+        original = pd.concat(
+            [original[col].astype("category") for col in original], axis=1
+        )
+        original.index.name = "index"
+        with tm.ensure_clean() as path:
+            original.to_stata(path, version=version)
+            written_and_read_again = self.read_dta(path)
+
+        res = written_and_read_again.set_index("index")
+
+        expected = original.copy()
+        for col in expected:
+            cat = expected[col]._values
+            new_cats = cat.remove_unused_categories().categories
+            cat = cat.set_categories(new_cats, ordered=True)
+            expected[col] = cat
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(res, expected)
+
+    @pytest.mark.parametrize("file", ["stata10_115", "stata10_117"])
+    def test_categorical_order(self, file, datapath):
+        # Directly construct using expected codes
+        # Format is is_cat, col_name, labels (in order), underlying data
+        expected = [
+            (True, "ordered", ["a", "b", "c", "d", "e"], np.arange(5)),
+            (True, "reverse", ["a", "b", "c", "d", "e"], np.arange(5)[::-1]),
+            (True, "noorder", ["a", "b", "c", "d", "e"], np.array([2, 1, 4, 0, 3])),
+            (True, "floating", ["a", "b", "c", "d", "e"], np.arange(0, 5)),
+            (True, "float_missing", ["a", "d", "e"], np.array([0, 1, 2, -1, -1])),
+            (False, "nolabel", [1.0, 2.0, 3.0, 4.0, 5.0], np.arange(5)),
+            (True, "int32_mixed", ["d", 2, "e", "b", "a"], np.arange(5)),
+        ]
+        cols = []
+        for is_cat, col, labels, codes in expected:
+            if is_cat:
+                cols.append(
+                    (col, pd.Categorical.from_codes(codes, labels, ordered=True))
+                )
+            else:
+                cols.append((col, Series(labels, dtype=np.float32)))
+        expected = DataFrame.from_dict(dict(cols))
+
+        # Read with and with out categoricals, ensure order is identical
+        file = datapath("io", "data", "stata", f"{file}.dta")
+        parsed = read_stata(file)
+        tm.assert_frame_equal(expected, parsed)
+
+        # Check identity of codes
+        for col in expected:
+            if isinstance(expected[col].dtype, CategoricalDtype):
+                tm.assert_series_equal(expected[col].cat.codes, parsed[col].cat.codes)
+                tm.assert_index_equal(
+                    expected[col].cat.categories, parsed[col].cat.categories
+                )
+
+    @pytest.mark.parametrize("file", ["stata11_115", "stata11_117"])
+    def test_categorical_sorting(self, file, datapath):
+        parsed = read_stata(datapath("io", "data", "stata", f"{file}.dta"))
+
+        # Sort based on codes, not strings
+        parsed = parsed.sort_values("srh", na_position="first")
+
+        # Don't sort index
+        parsed.index = pd.RangeIndex(len(parsed))
+        codes = [-1, -1, 0, 1, 1, 1, 2, 2, 3, 4]
+        categories = ["Poor", "Fair", "Good", "Very good", "Excellent"]
+        cat = pd.Categorical.from_codes(
+            codes=codes, categories=categories, ordered=True
+        )
+        expected = Series(cat, name="srh")
+        tm.assert_series_equal(expected, parsed["srh"])
+
+    @pytest.mark.parametrize("file", ["stata10_115", "stata10_117"])
+    def test_categorical_ordering(self, file, datapath):
+        file = datapath("io", "data", "stata", f"{file}.dta")
+        parsed = read_stata(file)
+
+        parsed_unordered = read_stata(file, order_categoricals=False)
+        for col in parsed:
+            if not isinstance(parsed[col].dtype, CategoricalDtype):
+                continue
+            assert parsed[col].cat.ordered
+            assert not parsed_unordered[col].cat.ordered
+
+    @pytest.mark.filterwarnings("ignore::UserWarning")
+    @pytest.mark.parametrize(
+        "file",
+        [
+            "stata1_117",
+            "stata2_117",
+            "stata3_117",
+            "stata4_117",
+            "stata5_117",
+            "stata6_117",
+            "stata7_117",
+            "stata8_117",
+            "stata9_117",
+            "stata10_117",
+            "stata11_117",
+        ],
+    )
+    @pytest.mark.parametrize("chunksize", [1, 2])
+    @pytest.mark.parametrize("convert_categoricals", [False, True])
+    @pytest.mark.parametrize("convert_dates", [False, True])
+    def test_read_chunks_117(
+        self, file, chunksize, convert_categoricals, convert_dates, datapath
+    ):
+        fname = datapath("io", "data", "stata", f"{file}.dta")
+
+        parsed = read_stata(
+            fname,
+            convert_categoricals=convert_categoricals,
+            convert_dates=convert_dates,
+        )
+        with read_stata(
+            fname,
+            iterator=True,
+            convert_categoricals=convert_categoricals,
+            convert_dates=convert_dates,
+        ) as itr:
+            pos = 0
+            for j in range(5):
+                try:
+                    chunk = itr.read(chunksize)
+                except StopIteration:
+                    break
+                from_frame = parsed.iloc[pos : pos + chunksize, :].copy()
+                from_frame = self._convert_categorical(from_frame)
+                tm.assert_frame_equal(
+                    from_frame, chunk, check_dtype=False, check_datetimelike_compat=True
+                )
+                pos += chunksize
+
+    @staticmethod
+    def _convert_categorical(from_frame: DataFrame) -> DataFrame:
+        """
+        Emulate the categorical casting behavior we expect from roundtripping.
+        """
+        for col in from_frame:
+            ser = from_frame[col]
+            if isinstance(ser.dtype, CategoricalDtype):
+                cat = ser._values.remove_unused_categories()
+                if cat.categories.dtype == object:
+                    categories = pd.Index._with_infer(cat.categories._values)
+                    cat = cat.set_categories(categories)
+                from_frame[col] = cat
+        return from_frame
+
+    def test_iterator(self, datapath):
+        fname = datapath("io", "data", "stata", "stata3_117.dta")
+
+        parsed = read_stata(fname)
+
+        with read_stata(fname, iterator=True) as itr:
+            chunk = itr.read(5)
+            tm.assert_frame_equal(parsed.iloc[0:5, :], chunk)
+
+        with read_stata(fname, chunksize=5) as itr:
+            chunk = list(itr)
+            tm.assert_frame_equal(parsed.iloc[0:5, :], chunk[0])
+
+        with read_stata(fname, iterator=True) as itr:
+            chunk = itr.get_chunk(5)
+            tm.assert_frame_equal(parsed.iloc[0:5, :], chunk)
+
+        with read_stata(fname, chunksize=5) as itr:
+            chunk = itr.get_chunk()
+            tm.assert_frame_equal(parsed.iloc[0:5, :], chunk)
+
+        # GH12153
+        with read_stata(fname, chunksize=4) as itr:
+            from_chunks = pd.concat(itr)
+        tm.assert_frame_equal(parsed, from_chunks)
+
+    @pytest.mark.filterwarnings("ignore::UserWarning")
+    @pytest.mark.parametrize(
+        "file",
+        [
+            "stata2_115",
+            "stata3_115",
+            "stata4_115",
+            "stata5_115",
+            "stata6_115",
+            "stata7_115",
+            "stata8_115",
+            "stata9_115",
+            "stata10_115",
+            "stata11_115",
+        ],
+    )
+    @pytest.mark.parametrize("chunksize", [1, 2])
+    @pytest.mark.parametrize("convert_categoricals", [False, True])
+    @pytest.mark.parametrize("convert_dates", [False, True])
+    def test_read_chunks_115(
+        self, file, chunksize, convert_categoricals, convert_dates, datapath
+    ):
+        fname = datapath("io", "data", "stata", f"{file}.dta")
+
+        # Read the whole file
+        parsed = read_stata(
+            fname,
+            convert_categoricals=convert_categoricals,
+            convert_dates=convert_dates,
+        )
+
+        # Compare to what we get when reading by chunk
+        with read_stata(
+            fname,
+            iterator=True,
+            convert_dates=convert_dates,
+            convert_categoricals=convert_categoricals,
+        ) as itr:
+            pos = 0
+            for j in range(5):
+                try:
+                    chunk = itr.read(chunksize)
+                except StopIteration:
+                    break
+                from_frame = parsed.iloc[pos : pos + chunksize, :].copy()
+                from_frame = self._convert_categorical(from_frame)
+                tm.assert_frame_equal(
+                    from_frame, chunk, check_dtype=False, check_datetimelike_compat=True
+                )
+                pos += chunksize
+
+    def test_read_chunks_columns(self, datapath):
+        fname = datapath("io", "data", "stata", "stata3_117.dta")
+        columns = ["quarter", "cpi", "m1"]
+        chunksize = 2
+
+        parsed = read_stata(fname, columns=columns)
+        with read_stata(fname, iterator=True) as itr:
+            pos = 0
+            for j in range(5):
+                chunk = itr.read(chunksize, columns=columns)
+                if chunk is None:
+                    break
+                from_frame = parsed.iloc[pos : pos + chunksize, :]
+                tm.assert_frame_equal(from_frame, chunk, check_dtype=False)
+                pos += chunksize
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_write_variable_labels(self, version, mixed_frame):
+        # GH 13631, add support for writing variable labels
+        mixed_frame.index.name = "index"
+        variable_labels = {"a": "City Rank", "b": "City Exponent", "c": "City"}
+        with tm.ensure_clean() as path:
+            mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
+            with StataReader(path) as sr:
+                read_labels = sr.variable_labels()
+            expected_labels = {
+                "index": "",
+                "a": "City Rank",
+                "b": "City Exponent",
+                "c": "City",
+            }
+            assert read_labels == expected_labels
+
+        variable_labels["index"] = "The Index"
+        with tm.ensure_clean() as path:
+            mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
+            with StataReader(path) as sr:
+                read_labels = sr.variable_labels()
+            assert read_labels == variable_labels
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_invalid_variable_labels(self, version, mixed_frame):
+        mixed_frame.index.name = "index"
+        variable_labels = {"a": "very long" * 10, "b": "City Exponent", "c": "City"}
+        with tm.ensure_clean() as path:
+            msg = "Variable labels must be 80 characters or fewer"
+            with pytest.raises(ValueError, match=msg):
+                mixed_frame.to_stata(
+                    path, variable_labels=variable_labels, version=version
+                )
+
+    @pytest.mark.parametrize("version", [114, 117])
+    def test_invalid_variable_label_encoding(self, version, mixed_frame):
+        mixed_frame.index.name = "index"
+        variable_labels = {"a": "very long" * 10, "b": "City Exponent", "c": "City"}
+        variable_labels["a"] = "invalid character Œ"
+        with tm.ensure_clean() as path:
+            with pytest.raises(
+                ValueError, match="Variable labels must contain only characters"
+            ):
+                mixed_frame.to_stata(
+                    path, variable_labels=variable_labels, version=version
+                )
+
+    def test_write_variable_label_errors(self, mixed_frame):
+        values = ["\u03A1", "\u0391", "\u039D", "\u0394", "\u0391", "\u03A3"]
+
+        variable_labels_utf8 = {
+            "a": "City Rank",
+            "b": "City Exponent",
+            "c": "".join(values),
+        }
+
+        msg = (
+            "Variable labels must contain only characters that can be "
+            "encoded in Latin-1"
+        )
+        with pytest.raises(ValueError, match=msg):
+            with tm.ensure_clean() as path:
+                mixed_frame.to_stata(path, variable_labels=variable_labels_utf8)
+
+        variable_labels_long = {
+            "a": "City Rank",
+            "b": "City Exponent",
+            "c": "A very, very, very long variable label "
+            "that is too long for Stata which means "
+            "that it has more than 80 characters",
+        }
+
+        msg = "Variable labels must be 80 characters or fewer"
+        with pytest.raises(ValueError, match=msg):
+            with tm.ensure_clean() as path:
+                mixed_frame.to_stata(path, variable_labels=variable_labels_long)
+
+    def test_default_date_conversion(self):
+        # GH 12259
+        dates = [
+            dt.datetime(1999, 12, 31, 12, 12, 12, 12000),
+            dt.datetime(2012, 12, 21, 12, 21, 12, 21000),
+            dt.datetime(1776, 7, 4, 7, 4, 7, 4000),
+        ]
+        original = DataFrame(
+            {
+                "nums": [1.0, 2.0, 3.0],
+                "strs": ["apple", "banana", "cherry"],
+                "dates": dates,
+            }
+        )
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path, write_index=False)
+            reread = read_stata(path, convert_dates=True)
+            tm.assert_frame_equal(original, reread)
+
+            original.to_stata(path, write_index=False, convert_dates={"dates": "tc"})
+            direct = read_stata(path, convert_dates=True)
+            tm.assert_frame_equal(reread, direct)
+
+            dates_idx = original.columns.tolist().index("dates")
+            original.to_stata(path, write_index=False, convert_dates={dates_idx: "tc"})
+            direct = read_stata(path, convert_dates=True)
+            tm.assert_frame_equal(reread, direct)
+
+    def test_unsupported_type(self):
+        original = DataFrame({"a": [1 + 2j, 2 + 4j]})
+
+        msg = "Data type complex128 not supported"
+        with pytest.raises(NotImplementedError, match=msg):
+            with tm.ensure_clean() as path:
+                original.to_stata(path)
+
+    def test_unsupported_datetype(self):
+        dates = [
+            dt.datetime(1999, 12, 31, 12, 12, 12, 12000),
+            dt.datetime(2012, 12, 21, 12, 21, 12, 21000),
+            dt.datetime(1776, 7, 4, 7, 4, 7, 4000),
+        ]
+        original = DataFrame(
+            {
+                "nums": [1.0, 2.0, 3.0],
+                "strs": ["apple", "banana", "cherry"],
+                "dates": dates,
+            }
+        )
+
+        msg = "Format %tC not implemented"
+        with pytest.raises(NotImplementedError, match=msg):
+            with tm.ensure_clean() as path:
+                original.to_stata(path, convert_dates={"dates": "tC"})
+
+        dates = pd.date_range("1-1-1990", periods=3, tz="Asia/Hong_Kong")
+        original = DataFrame(
+            {
+                "nums": [1.0, 2.0, 3.0],
+                "strs": ["apple", "banana", "cherry"],
+                "dates": dates,
+            }
+        )
+        with pytest.raises(NotImplementedError, match="Data type datetime64"):
+            with tm.ensure_clean() as path:
+                original.to_stata(path)
+
+    def test_repeated_column_labels(self, datapath):
+        # GH 13923, 25772
+        msg = """
+Value labels for column ethnicsn are not unique. These cannot be converted to
+pandas categoricals.
+
+Either read the file with `convert_categoricals` set to False or use the
+low level interface in `StataReader` to separately read the values and the
+value_labels.
+
+The repeated labels are:\n-+\nwolof
+"""
+        with pytest.raises(ValueError, match=msg):
+            read_stata(
+                datapath("io", "data", "stata", "stata15.dta"),
+                convert_categoricals=True,
+            )
+
+    def test_stata_111(self, datapath):
+        # 111 is an old version but still used by current versions of
+        # SAS when exporting to Stata format. We do not know of any
+        # on-line documentation for this version.
+        df = read_stata(datapath("io", "data", "stata", "stata7_111.dta"))
+        original = DataFrame(
+            {
+                "y": [1, 1, 1, 1, 1, 0, 0, np.nan, 0, 0],
+                "x": [1, 2, 1, 3, np.nan, 4, 3, 5, 1, 6],
+                "w": [2, np.nan, 5, 2, 4, 4, 3, 1, 2, 3],
+                "z": ["a", "b", "c", "d", "e", "", "g", "h", "i", "j"],
+            }
+        )
+        original = original[["y", "x", "w", "z"]]
+        tm.assert_frame_equal(original, df)
+
+    def test_out_of_range_double(self):
+        # GH 14618
+        df = DataFrame(
+            {
+                "ColumnOk": [0.0, np.finfo(np.double).eps, 4.49423283715579e307],
+                "ColumnTooBig": [0.0, np.finfo(np.double).eps, np.finfo(np.double).max],
+            }
+        )
+        msg = (
+            r"Column ColumnTooBig has a maximum value \(.+\) outside the range "
+            r"supported by Stata \(.+\)"
+        )
+        with pytest.raises(ValueError, match=msg):
+            with tm.ensure_clean() as path:
+                df.to_stata(path)
+
+    def test_out_of_range_float(self):
+        original = DataFrame(
+            {
+                "ColumnOk": [
+                    0.0,
+                    np.finfo(np.float32).eps,
+                    np.finfo(np.float32).max / 10.0,
+                ],
+                "ColumnTooBig": [
+                    0.0,
+                    np.finfo(np.float32).eps,
+                    np.finfo(np.float32).max,
+                ],
+            }
+        )
+        original.index.name = "index"
+        for col in original:
+            original[col] = original[col].astype(np.float32)
+
+        with tm.ensure_clean() as path:
+            original.to_stata(path)
+            reread = read_stata(path)
+
+        original["ColumnTooBig"] = original["ColumnTooBig"].astype(np.float64)
+        expected = original.copy()
+        expected.index = expected.index.astype(np.int32)
+        tm.assert_frame_equal(reread.set_index("index"), expected)
+
+    @pytest.mark.parametrize("infval", [np.inf, -np.inf])
+    def test_inf(self, infval):
+        # GH 45350
+        df = DataFrame({"WithoutInf": [0.0, 1.0], "WithInf": [2.0, infval]})
+        msg = (
+            "Column WithInf contains infinity or -infinity"
+            "which is outside the range supported by Stata."
+        )
+        with pytest.raises(ValueError, match=msg):
+            with tm.ensure_clean() as path:
+                df.to_stata(path)
+
+    def test_path_pathlib(self):
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        df.index.name = "index"
+        reader = lambda x: read_stata(x).set_index("index")
+        result = tm.round_trip_pathlib(df.to_stata, reader)
+        tm.assert_frame_equal(df, result)
+
+    def test_pickle_path_localpath(self):
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        df.index.name = "index"
+        reader = lambda x: read_stata(x).set_index("index")
+        result = tm.round_trip_localpath(df.to_stata, reader)
+        tm.assert_frame_equal(df, result)
+
+    @pytest.mark.parametrize("write_index", [True, False])
+    def test_value_labels_iterator(self, write_index):
+        # GH 16923
+        d = {"A": ["B", "E", "C", "A", "E"]}
+        df = DataFrame(data=d)
+        df["A"] = df["A"].astype("category")
+        with tm.ensure_clean() as path:
+            df.to_stata(path, write_index=write_index)
+
+            with read_stata(path, iterator=True) as dta_iter:
+                value_labels = dta_iter.value_labels()
+        assert value_labels == {"A": {0: "A", 1: "B", 2: "C", 3: "E"}}
+
+    def test_set_index(self):
+        # GH 17328
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        df.index.name = "index"
+        with tm.ensure_clean() as path:
+            df.to_stata(path)
+            reread = read_stata(path, index_col="index")
+        tm.assert_frame_equal(df, reread)
+
+    @pytest.mark.parametrize(
+        "column", ["ms", "day", "week", "month", "qtr", "half", "yr"]
+    )
+    def test_date_parsing_ignores_format_details(self, column, datapath):
+        # GH 17797
+        #
+        # Test that display formats are ignored when determining if a numeric
+        # column is a date value.
+        #
+        # All date types are stored as numbers and format associated with the
+        # column denotes both the type of the date and the display format.
+        #
+        # STATA supports 9 date types which each have distinct units. We test 7
+        # of the 9 types, ignoring %tC and %tb. %tC is a variant of %tc that
+        # accounts for leap seconds and %tb relies on STATAs business calendar.
+        df = read_stata(datapath("io", "data", "stata", "stata13_dates.dta"))
+        unformatted = df.loc[0, column]
+        formatted = df.loc[0, column + "_fmt"]
+        assert unformatted == formatted
+
+    def test_writer_117(self):
+        original = DataFrame(
+            data=[
+                [
+                    "string",
+                    "object",
+                    1,
+                    1,
+                    1,
+                    1.1,
+                    1.1,
+                    np.datetime64("2003-12-25"),
+                    "a",
+                    "a" * 2045,
+                    "a" * 5000,
+                    "a",
+                ],
+                [
+                    "string-1",
+                    "object-1",
+                    1,
+                    1,
+                    1,
+                    1.1,
+                    1.1,
+                    np.datetime64("2003-12-26"),
+                    "b",
+                    "b" * 2045,
+                    "",
+                    "",
+                ],
+            ],
+            columns=[
+                "string",
+                "object",
+                "int8",
+                "int16",
+                "int32",
+                "float32",
+                "float64",
+                "datetime",
+                "s1",
+                "s2045",
+                "srtl",
+                "forced_strl",
+            ],
+        )
+        original["object"] = Series(original["object"], dtype=object)
+        original["int8"] = Series(original["int8"], dtype=np.int8)
+        original["int16"] = Series(original["int16"], dtype=np.int16)
+        original["int32"] = original["int32"].astype(np.int32)
+        original["float32"] = Series(original["float32"], dtype=np.float32)
+        original.index.name = "index"
+        original.index = original.index.astype(np.int32)
+        copy = original.copy()
+        with tm.ensure_clean() as path:
+            original.to_stata(
+                path,
+                convert_dates={"datetime": "tc"},
+                convert_strl=["forced_strl"],
+                version=117,
+            )
+            written_and_read_again = self.read_dta(path)
+            # original.index is np.int32, read index is np.int64
+            tm.assert_frame_equal(
+                written_and_read_again.set_index("index"),
+                original,
+                check_index_type=False,
+            )
+            tm.assert_frame_equal(original, copy)
+
+    def test_convert_strl_name_swap(self):
+        original = DataFrame(
+            [["a" * 3000, "A", "apple"], ["b" * 1000, "B", "banana"]],
+            columns=["long1" * 10, "long", 1],
+        )
+        original.index.name = "index"
+
+        with tm.assert_produces_warning(InvalidColumnName):
+            with tm.ensure_clean() as path:
+                original.to_stata(path, convert_strl=["long", 1], version=117)
+                reread = self.read_dta(path)
+                reread = reread.set_index("index")
+                reread.columns = original.columns
+                tm.assert_frame_equal(reread, original, check_index_type=False)
+
+    def test_invalid_date_conversion(self):
+        # GH 12259
+        dates = [
+            dt.datetime(1999, 12, 31, 12, 12, 12, 12000),
+            dt.datetime(2012, 12, 21, 12, 21, 12, 21000),
+            dt.datetime(1776, 7, 4, 7, 4, 7, 4000),
+        ]
+        original = DataFrame(
+            {
+                "nums": [1.0, 2.0, 3.0],
+                "strs": ["apple", "banana", "cherry"],
+                "dates": dates,
+            }
+        )
+
+        with tm.ensure_clean() as path:
+            msg = "convert_dates key must be a column or an integer"
+            with pytest.raises(ValueError, match=msg):
+                original.to_stata(path, convert_dates={"wrong_name": "tc"})
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_nonfile_writing(self, version):
+        # GH 21041
+        bio = io.BytesIO()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        df.index.name = "index"
+        with tm.ensure_clean() as path:
+            df.to_stata(bio, version=version)
+            bio.seek(0)
+            with open(path, "wb") as dta:
+                dta.write(bio.read())
+            reread = read_stata(path, index_col="index")
+        tm.assert_frame_equal(df, reread)
+
+    def test_gzip_writing(self):
+        # writing version 117 requires seek and cannot be used with gzip
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        df.index.name = "index"
+        with tm.ensure_clean() as path:
+            with gzip.GzipFile(path, "wb") as gz:
+                df.to_stata(gz, version=114)
+            with gzip.GzipFile(path, "rb") as gz:
+                reread = read_stata(gz, index_col="index")
+        tm.assert_frame_equal(df, reread)
+
+    def test_unicode_dta_118(self, datapath):
+        unicode_df = self.read_dta(datapath("io", "data", "stata", "stata16_118.dta"))
+
+        columns = ["utf8", "latin1", "ascii", "utf8_strl", "ascii_strl"]
+        values = [
+            ["ραηδας", "PÄNDÄS", "p", "ραηδας", "p"],
+            ["ƤĀńĐąŜ", "Ö", "a", "ƤĀńĐąŜ", "a"],
+            ["ᴘᴀᴎᴅᴀS", "Ü", "n", "ᴘᴀᴎᴅᴀS", "n"],
+            ["      ", "      ", "d", "      ", "d"],
+            [" ", "", "a", " ", "a"],
+            ["", "", "s", "", "s"],
+            ["", "", " ", "", " "],
+        ]
+        expected = DataFrame(values, columns=columns)
+
+        tm.assert_frame_equal(unicode_df, expected)
+
+    def test_mixed_string_strl(self):
+        # GH 23633
+        output = [{"mixed": "string" * 500, "number": 0}, {"mixed": None, "number": 1}]
+        output = DataFrame(output)
+        output.number = output.number.astype("int32")
+
+        with tm.ensure_clean() as path:
+            output.to_stata(path, write_index=False, version=117)
+            reread = read_stata(path)
+            expected = output.fillna("")
+            tm.assert_frame_equal(reread, expected)
+
+            # Check strl supports all None (null)
+            output["mixed"] = None
+            output.to_stata(
+                path, write_index=False, convert_strl=["mixed"], version=117
+            )
+            reread = read_stata(path)
+            expected = output.fillna("")
+            tm.assert_frame_equal(reread, expected)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_all_none_exception(self, version):
+        output = [{"none": "none", "number": 0}, {"none": None, "number": 1}]
+        output = DataFrame(output)
+        output["none"] = None
+        with tm.ensure_clean() as path:
+            with pytest.raises(ValueError, match="Column `none` cannot be exported"):
+                output.to_stata(path, version=version)
+
+    @pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+    def test_invalid_file_not_written(self, version):
+        content = "Here is one __�__ Another one __·__ Another one __½__"
+        df = DataFrame([content], columns=["invalid"])
+        with tm.ensure_clean() as path:
+            msg1 = (
+                r"'latin-1' codec can't encode character '\\ufffd' "
+                r"in position 14: ordinal not in range\(256\)"
+            )
+            msg2 = (
+                "'ascii' codec can't decode byte 0xef in position 14: "
+                r"ordinal not in range\(128\)"
+            )
+            with pytest.raises(UnicodeEncodeError, match=f"{msg1}|{msg2}"):
+                df.to_stata(path)
+
+    def test_strl_latin1(self):
+        # GH 23573, correct GSO data to reflect correct size
+        output = DataFrame(
+            [["pandas"] * 2, ["þâÑÐŧ"] * 2], columns=["var_str", "var_strl"]
+        )
+
+        with tm.ensure_clean() as path:
+            output.to_stata(path, version=117, convert_strl=["var_strl"])
+            with open(path, "rb") as reread:
+                content = reread.read()
+                expected = "þâÑÐŧ"
+                assert expected.encode("latin-1") in content
+                assert expected.encode("utf-8") in content
+                gsos = content.split(b"strls")[1][1:-2]
+                for gso in gsos.split(b"GSO")[1:]:
+                    val = gso.split(b"\x00")[-2]
+                    size = gso[gso.find(b"\x82") + 1]
+                    assert len(val) == size - 1
+
+    def test_encoding_latin1_118(self, datapath):
+        # GH 25960
+        msg = """
+One or more strings in the dta file could not be decoded using utf-8, and
+so the fallback encoding of latin-1 is being used.  This can happen when a file
+has been incorrectly encoded by Stata or some other software. You should verify
+the string values returned are correct."""
+        # Move path outside of read_stata, or else assert_produces_warning
+        # will block pytests skip mechanism from triggering (failing the test)
+        # if the path is not present
+        path = datapath("io", "data", "stata", "stata1_encoding_118.dta")
+        with tm.assert_produces_warning(UnicodeWarning, filter_level="once") as w:
+            encoded = read_stata(path)
+            # with filter_level="always", produces 151 warnings which can be slow
+            assert len(w) == 1
+            assert w[0].message.args[0] == msg
+
+        expected = DataFrame([["Düsseldorf"]] * 151, columns=["kreis1849"])
+        tm.assert_frame_equal(encoded, expected)
+
+    @pytest.mark.slow
+    def test_stata_119(self, datapath):
+        # Gzipped since contains 32,999 variables and uncompressed is 20MiB
+        # Just validate that the reader reports correct number of variables
+        # to avoid high peak memory
+        with gzip.open(
+            datapath("io", "data", "stata", "stata1_119.dta.gz"), "rb"
+        ) as gz:
+            with StataReader(gz) as reader:
+                reader._ensure_open()
+                assert reader._nvar == 32999
+
+    @pytest.mark.parametrize("version", [118, 119, None])
+    def test_utf8_writer(self, version):
+        cat = pd.Categorical(["a", "β", "ĉ"], ordered=True)
+        data = DataFrame(
+            [
+                [1.0, 1, "ᴬ", "ᴀ relatively long ŝtring"],
+                [2.0, 2, "ᴮ", ""],
+                [3.0, 3, "ᴰ", None],
+            ],
+            columns=["Å", "β", "ĉ", "strls"],
+        )
+        data["ᴐᴬᵀ"] = cat
+        variable_labels = {
+            "Å": "apple",
+            "β": "ᵈᵉᵊ",
+            "ĉ": "ᴎტჄႲႳႴႶႺ",
+            "strls": "Long Strings",
+            "ᴐᴬᵀ": "",
+        }
+        data_label = "ᴅaᵀa-label"
+        value_labels = {"β": {1: "label", 2: "æøå", 3: "ŋot valid latin-1"}}
+        data["β"] = data["β"].astype(np.int32)
+        with tm.ensure_clean() as path:
+            writer = StataWriterUTF8(
+                path,
+                data,
+                data_label=data_label,
+                convert_strl=["strls"],
+                variable_labels=variable_labels,
+                write_index=False,
+                version=version,
+                value_labels=value_labels,
+            )
+            writer.write_file()
+            reread_encoded = read_stata(path)
+            # Missing is intentionally converted to empty strl
+            data["strls"] = data["strls"].fillna("")
+            # Variable with value labels is reread as categorical
+            data["β"] = (
+                data["β"].replace(value_labels["β"]).astype("category").cat.as_ordered()
+            )
+            tm.assert_frame_equal(data, reread_encoded)
+            with StataReader(path) as reader:
+                assert reader.data_label == data_label
+                assert reader.variable_labels() == variable_labels
+
+            data.to_stata(path, version=version, write_index=False)
+            reread_to_stata = read_stata(path)
+            tm.assert_frame_equal(data, reread_to_stata)
+
+    def test_writer_118_exceptions(self):
+        df = DataFrame(np.zeros((1, 33000), dtype=np.int8))
+        with tm.ensure_clean() as path:
+            with pytest.raises(ValueError, match="version must be either 118 or 119."):
+                StataWriterUTF8(path, df, version=117)
+        with tm.ensure_clean() as path:
+            with pytest.raises(ValueError, match="You must use version 119"):
+                StataWriterUTF8(path, df, version=118)
+
+    @pytest.mark.parametrize(
+        "dtype_backend",
+        ["numpy_nullable", pytest.param("pyarrow", marks=td.skip_if_no("pyarrow"))],
+    )
+    def test_read_write_ea_dtypes(self, dtype_backend):
+        df = DataFrame(
+            {
+                "a": [1, 2, None],
+                "b": ["a", "b", "c"],
+                "c": [True, False, None],
+                "d": [1.5, 2.5, 3.5],
+                "e": pd.date_range("2020-12-31", periods=3, freq="D"),
+            },
+            index=pd.Index([0, 1, 2], name="index"),
+        )
+        df = df.convert_dtypes(dtype_backend=dtype_backend)
+        df.to_stata("test_stata.dta", version=118)
+
+        with tm.ensure_clean() as path:
+            df.to_stata(path)
+            written_and_read_again = self.read_dta(path)
+
+        expected = DataFrame(
+            {
+                "a": [1, 2, np.nan],
+                "b": ["a", "b", "c"],
+                "c": [1.0, 0, np.nan],
+                "d": [1.5, 2.5, 3.5],
+                "e": pd.date_range("2020-12-31", periods=3, freq="D"),
+            },
+            index=pd.Index([0, 1, 2], name="index", dtype=np.int32),
+        )
+
+        tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
+
+@pytest.mark.parametrize("version", [105, 108, 111, 113, 114])
+def test_backward_compat(version, datapath):
+    data_base = datapath("io", "data", "stata")
+    ref = os.path.join(data_base, "stata-compat-118.dta")
+    old = os.path.join(data_base, f"stata-compat-{version}.dta")
+    expected = read_stata(ref)
+    old_dta = read_stata(old)
+    tm.assert_frame_equal(old_dta, expected, check_dtype=False)
+
+
+def test_direct_read(datapath, monkeypatch):
+    file_path = datapath("io", "data", "stata", "stata-compat-118.dta")
+
+    # Test that opening a file path doesn't buffer the file.
+    with StataReader(file_path) as reader:
+        # Must not have been buffered to memory
+        assert not reader.read().empty
+        assert not isinstance(reader._path_or_buf, io.BytesIO)
+
+    # Test that we use a given fp exactly, if possible.
+    with open(file_path, "rb") as fp:
+        with StataReader(fp) as reader:
+            assert not reader.read().empty
+            assert reader._path_or_buf is fp
+
+    # Test that we use a given BytesIO exactly, if possible.
+    with open(file_path, "rb") as fp:
+        with io.BytesIO(fp.read()) as bio:
+            with StataReader(bio) as reader:
+                assert not reader.read().empty
+                assert reader._path_or_buf is bio
+
+
+def test_statareader_warns_when_used_without_context(datapath):
+    file_path = datapath("io", "data", "stata", "stata-compat-118.dta")
+    with tm.assert_produces_warning(
+        ResourceWarning,
+        match="without using a context manager",
+    ):
+        sr = StataReader(file_path)
+        sr.read()
+    with tm.assert_produces_warning(
+        FutureWarning,
+        match="is not part of the public API",
+    ):
+        sr.close()
+
+
+@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+@pytest.mark.parametrize("use_dict", [True, False])
+@pytest.mark.parametrize("infer", [True, False])
+def test_compression(compression, version, use_dict, infer, compression_to_extension):
+    file_name = "dta_inferred_compression.dta"
+    if compression:
+        if use_dict:
+            file_ext = compression
+        else:
+            file_ext = compression_to_extension[compression]
+        file_name += f".{file_ext}"
+    compression_arg = compression
+    if infer:
+        compression_arg = "infer"
+    if use_dict:
+        compression_arg = {"method": compression}
+
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((10, 2)), columns=list("AB")
+    )
+    df.index.name = "index"
+    with tm.ensure_clean(file_name) as path:
+        df.to_stata(path, version=version, compression=compression_arg)
+        if compression == "gzip":
+            with gzip.open(path, "rb") as comp:
+                fp = io.BytesIO(comp.read())
+        elif compression == "zip":
+            with zipfile.ZipFile(path, "r") as comp:
+                fp = io.BytesIO(comp.read(comp.filelist[0]))
+        elif compression == "tar":
+            with tarfile.open(path) as tar:
+                fp = io.BytesIO(tar.extractfile(tar.getnames()[0]).read())
+        elif compression == "bz2":
+            with bz2.open(path, "rb") as comp:
+                fp = io.BytesIO(comp.read())
+        elif compression == "zstd":
+            zstd = pytest.importorskip("zstandard")
+            with zstd.open(path, "rb") as comp:
+                fp = io.BytesIO(comp.read())
+        elif compression == "xz":
+            lzma = pytest.importorskip("lzma")
+            with lzma.open(path, "rb") as comp:
+                fp = io.BytesIO(comp.read())
+        elif compression is None:
+            fp = path
+        reread = read_stata(fp, index_col="index")
+
+    expected = df.copy()
+    expected.index = expected.index.astype(np.int32)
+    tm.assert_frame_equal(reread, expected)
+
+
+@pytest.mark.parametrize("method", ["zip", "infer"])
+@pytest.mark.parametrize("file_ext", [None, "dta", "zip"])
+def test_compression_dict(method, file_ext):
+    file_name = f"test.{file_ext}"
+    archive_name = "test.dta"
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((10, 2)), columns=list("AB")
+    )
+    df.index.name = "index"
+    with tm.ensure_clean(file_name) as path:
+        compression = {"method": method, "archive_name": archive_name}
+        df.to_stata(path, compression=compression)
+        if method == "zip" or file_ext == "zip":
+            with zipfile.ZipFile(path, "r") as zp:
+                assert len(zp.filelist) == 1
+                assert zp.filelist[0].filename == archive_name
+                fp = io.BytesIO(zp.read(zp.filelist[0]))
+        else:
+            fp = path
+        reread = read_stata(fp, index_col="index")
+
+    expected = df.copy()
+    expected.index = expected.index.astype(np.int32)
+    tm.assert_frame_equal(reread, expected)
+
+
+@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+def test_chunked_categorical(version):
+    df = DataFrame({"cats": Series(["a", "b", "a", "b", "c"], dtype="category")})
+    df.index.name = "index"
+
+    expected = df.copy()
+    expected.index = expected.index.astype(np.int32)
+
+    with tm.ensure_clean() as path:
+        df.to_stata(path, version=version)
+        with StataReader(path, chunksize=2, order_categoricals=False) as reader:
+            for i, block in enumerate(reader):
+                block = block.set_index("index")
+                assert "cats" in block
+                tm.assert_series_equal(
+                    block.cats, expected.cats.iloc[2 * i : 2 * (i + 1)]
+                )
+
+
+def test_chunked_categorical_partial(datapath):
+    dta_file = datapath("io", "data", "stata", "stata-dta-partially-labeled.dta")
+    values = ["a", "b", "a", "b", 3.0]
+    with StataReader(dta_file, chunksize=2) as reader:
+        with tm.assert_produces_warning(CategoricalConversionWarning):
+            for i, block in enumerate(reader):
+                assert list(block.cats) == values[2 * i : 2 * (i + 1)]
+                if i < 2:
+                    idx = pd.Index(["a", "b"])
+                else:
+                    idx = pd.Index([3.0], dtype="float64")
+                tm.assert_index_equal(block.cats.cat.categories, idx)
+    with tm.assert_produces_warning(CategoricalConversionWarning):
+        with StataReader(dta_file, chunksize=5) as reader:
+            large_chunk = reader.__next__()
+    direct = read_stata(dta_file)
+    tm.assert_frame_equal(direct, large_chunk)
+
+
+@pytest.mark.parametrize("chunksize", (-1, 0, "apple"))
+def test_iterator_errors(datapath, chunksize):
+    dta_file = datapath("io", "data", "stata", "stata-dta-partially-labeled.dta")
+    with pytest.raises(ValueError, match="chunksize must be a positive"):
+        with StataReader(dta_file, chunksize=chunksize):
+            pass
+
+
+def test_iterator_value_labels():
+    # GH 31544
+    values = ["c_label", "b_label"] + ["a_label"] * 500
+    df = DataFrame({f"col{k}": pd.Categorical(values, ordered=True) for k in range(2)})
+    with tm.ensure_clean() as path:
+        df.to_stata(path, write_index=False)
+        expected = pd.Index(["a_label", "b_label", "c_label"], dtype="object")
+        with read_stata(path, chunksize=100) as reader:
+            for j, chunk in enumerate(reader):
+                for i in range(2):
+                    tm.assert_index_equal(chunk.dtypes.iloc[i].categories, expected)
+                tm.assert_frame_equal(chunk, df.iloc[j * 100 : (j + 1) * 100])
+
+
+def test_precision_loss():
+    df = DataFrame(
+        [[sum(2**i for i in range(60)), sum(2**i for i in range(52))]],
+        columns=["big", "little"],
+    )
+    with tm.ensure_clean() as path:
+        with tm.assert_produces_warning(
+            PossiblePrecisionLoss, match="Column converted from int64 to float64"
+        ):
+            df.to_stata(path, write_index=False)
+        reread = read_stata(path)
+        expected_dt = Series([np.float64, np.float64], index=["big", "little"])
+        tm.assert_series_equal(reread.dtypes, expected_dt)
+        assert reread.loc[0, "little"] == df.loc[0, "little"]
+        assert reread.loc[0, "big"] == float(df.loc[0, "big"])
+
+
+def test_compression_roundtrip(compression):
+    df = DataFrame(
+        [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+        index=["A", "B"],
+        columns=["X", "Y", "Z"],
+    )
+    df.index.name = "index"
+
+    with tm.ensure_clean() as path:
+        df.to_stata(path, compression=compression)
+        reread = read_stata(path, compression=compression, index_col="index")
+        tm.assert_frame_equal(df, reread)
+
+        # explicitly ensure file was compressed.
+        with tm.decompress_file(path, compression) as fh:
+            contents = io.BytesIO(fh.read())
+        reread = read_stata(contents, index_col="index")
+        tm.assert_frame_equal(df, reread)
+
+
+@pytest.mark.parametrize("to_infer", [True, False])
+@pytest.mark.parametrize("read_infer", [True, False])
+def test_stata_compression(
+    compression_only, read_infer, to_infer, compression_to_extension
+):
+    compression = compression_only
+
+    ext = compression_to_extension[compression]
+    filename = f"test.{ext}"
+
+    df = DataFrame(
+        [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+        index=["A", "B"],
+        columns=["X", "Y", "Z"],
+    )
+    df.index.name = "index"
+
+    to_compression = "infer" if to_infer else compression
+    read_compression = "infer" if read_infer else compression
+
+    with tm.ensure_clean(filename) as path:
+        df.to_stata(path, compression=to_compression)
+        result = read_stata(path, compression=read_compression, index_col="index")
+        tm.assert_frame_equal(result, df)
+
+
+def test_non_categorical_value_labels():
+    data = DataFrame(
+        {
+            "fully_labelled": [1, 2, 3, 3, 1],
+            "partially_labelled": [1.0, 2.0, np.nan, 9.0, np.nan],
+            "Y": [7, 7, 9, 8, 10],
+            "Z": pd.Categorical(["j", "k", "l", "k", "j"]),
+        }
+    )
+
+    with tm.ensure_clean() as path:
+        value_labels = {
+            "fully_labelled": {1: "one", 2: "two", 3: "three"},
+            "partially_labelled": {1.0: "one", 2.0: "two"},
+        }
+        expected = {**value_labels, "Z": {0: "j", 1: "k", 2: "l"}}
+
+        writer = StataWriter(path, data, value_labels=value_labels)
+        writer.write_file()
+
+        with StataReader(path) as reader:
+            reader_value_labels = reader.value_labels()
+            assert reader_value_labels == expected
+
+        msg = "Can't create value labels for notY, it wasn't found in the dataset."
+        with pytest.raises(KeyError, match=msg):
+            value_labels = {"notY": {7: "label1", 8: "label2"}}
+            StataWriter(path, data, value_labels=value_labels)
+
+        msg = (
+            "Can't create value labels for Z, value labels "
+            "can only be applied to numeric columns."
+        )
+        with pytest.raises(ValueError, match=msg):
+            value_labels = {"Z": {1: "a", 2: "k", 3: "j", 4: "i"}}
+            StataWriter(path, data, value_labels=value_labels)
+
+
+def test_non_categorical_value_label_name_conversion():
+    # Check conversion of invalid variable names
+    data = DataFrame(
+        {
+            "invalid~!": [1, 1, 2, 3, 5, 8],  # Only alphanumeric and _
+            "6_invalid": [1, 1, 2, 3, 5, 8],  # Must start with letter or _
+            "invalid_name_longer_than_32_characters": [8, 8, 9, 9, 8, 8],  # Too long
+            "aggregate": [2, 5, 5, 6, 6, 9],  # Reserved words
+            (1, 2): [1, 2, 3, 4, 5, 6],  # Hashable non-string
+        }
+    )
+
+    value_labels = {
+        "invalid~!": {1: "label1", 2: "label2"},
+        "6_invalid": {1: "label1", 2: "label2"},
+        "invalid_name_longer_than_32_characters": {8: "eight", 9: "nine"},
+        "aggregate": {5: "five"},
+        (1, 2): {3: "three"},
+    }
+
+    expected = {
+        "invalid__": {1: "label1", 2: "label2"},
+        "_6_invalid": {1: "label1", 2: "label2"},
+        "invalid_name_longer_than_32_char": {8: "eight", 9: "nine"},
+        "_aggregate": {5: "five"},
+        "_1__2_": {3: "three"},
+    }
+
+    with tm.ensure_clean() as path:
+        with tm.assert_produces_warning(InvalidColumnName):
+            data.to_stata(path, value_labels=value_labels)
+
+        with StataReader(path) as reader:
+            reader_value_labels = reader.value_labels()
+            assert reader_value_labels == expected
+
+
+def test_non_categorical_value_label_convert_categoricals_error():
+    # Mapping more than one value to the same label is valid for Stata
+    # labels, but can't be read with convert_categoricals=True
+    value_labels = {
+        "repeated_labels": {10: "Ten", 20: "More than ten", 40: "More than ten"}
+    }
+
+    data = DataFrame(
+        {
+            "repeated_labels": [10, 10, 20, 20, 40, 40],
+        }
+    )
+
+    with tm.ensure_clean() as path:
+        data.to_stata(path, value_labels=value_labels)
+
+        with StataReader(path, convert_categoricals=False) as reader:
+            reader_value_labels = reader.value_labels()
+        assert reader_value_labels == value_labels
+
+        col = "repeated_labels"
+        repeats = "-" * 80 + "\n" + "\n".join(["More than ten"])
+
+        msg = f"""
+Value labels for column {col} are not unique. These cannot be converted to
+pandas categoricals.
+
+Either read the file with `convert_categoricals` set to False or use the
+low level interface in `StataReader` to separately read the values and the
+value_labels.
+
+The repeated labels are:
+{repeats}
+"""
+        with pytest.raises(ValueError, match=msg):
+            read_stata(path, convert_categoricals=True)
+
+
+@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        pd.BooleanDtype,
+        pd.Int8Dtype,
+        pd.Int16Dtype,
+        pd.Int32Dtype,
+        pd.Int64Dtype,
+        pd.UInt8Dtype,
+        pd.UInt16Dtype,
+        pd.UInt32Dtype,
+        pd.UInt64Dtype,
+    ],
+)
+def test_nullable_support(dtype, version):
+    df = DataFrame(
+        {
+            "a": Series([1.0, 2.0, 3.0]),
+            "b": Series([1, pd.NA, pd.NA], dtype=dtype.name),
+            "c": Series(["a", "b", None]),
+        }
+    )
+    dtype_name = df.b.dtype.numpy_dtype.name
+    # Only use supported names: no uint, bool or int64
+    dtype_name = dtype_name.replace("u", "")
+    if dtype_name == "int64":
+        dtype_name = "int32"
+    elif dtype_name == "bool":
+        dtype_name = "int8"
+    value = StataMissingValue.BASE_MISSING_VALUES[dtype_name]
+    smv = StataMissingValue(value)
+    expected_b = Series([1, smv, smv], dtype=object, name="b")
+    expected_c = Series(["a", "b", ""], name="c")
+    with tm.ensure_clean() as path:
+        df.to_stata(path, write_index=False, version=version)
+        reread = read_stata(path, convert_missing=True)
+        tm.assert_series_equal(df.a, reread.a)
+        tm.assert_series_equal(reread.b, expected_b)
+        tm.assert_series_equal(reread.c, expected_c)
+
+
+def test_empty_frame():
+    # GH 46240
+    # create an empty DataFrame with int64 and float64 dtypes
+    df = DataFrame(data={"a": range(3), "b": [1.0, 2.0, 3.0]}).head(0)
+    with tm.ensure_clean() as path:
+        df.to_stata(path, write_index=False, version=117)
+        # Read entire dataframe
+        df2 = read_stata(path)
+        assert "b" in df2
+        # Dtypes don't match since no support for int32
+        dtypes = Series({"a": np.dtype("int32"), "b": np.dtype("float64")})
+        tm.assert_series_equal(df2.dtypes, dtypes)
+        # read one column of empty .dta file
+        df3 = read_stata(path, columns=["a"])
+        assert "b" not in df3
+        tm.assert_series_equal(df3.dtypes, dtypes.loc[["a"]])

llmeval-env/lib/python3.10/site-packages/pandas/tests/plotting/common.py

@@ -0,0 +1,563 @@
+"""
+Module consolidating common testing functions for checking plotting.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from pandas.core.dtypes.api import is_list_like
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from matplotlib.axes import Axes
+
+
+def _check_legend_labels(axes, labels=None, visible=True):
+    """
+    Check each axes has expected legend labels
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    labels : list-like
+        expected legend labels
+    visible : bool
+        expected legend visibility. labels are checked only when visible is
+        True
+    """
+    if visible and (labels is None):
+        raise ValueError("labels must be specified when visible is True")
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        if visible:
+            assert ax.get_legend() is not None
+            _check_text_labels(ax.get_legend().get_texts(), labels)
+        else:
+            assert ax.get_legend() is None
+
+
+def _check_legend_marker(ax, expected_markers=None, visible=True):
+    """
+    Check ax has expected legend markers
+
+    Parameters
+    ----------
+    ax : matplotlib Axes object
+    expected_markers : list-like
+        expected legend markers
+    visible : bool
+        expected legend visibility. labels are checked only when visible is
+        True
+    """
+    if visible and (expected_markers is None):
+        raise ValueError("Markers must be specified when visible is True")
+    if visible:
+        handles, _ = ax.get_legend_handles_labels()
+        markers = [handle.get_marker() for handle in handles]
+        assert markers == expected_markers
+    else:
+        assert ax.get_legend() is None
+
+
+def _check_data(xp, rs):
+    """
+    Check each axes has identical lines
+
+    Parameters
+    ----------
+    xp : matplotlib Axes object
+    rs : matplotlib Axes object
+    """
+    import matplotlib.pyplot as plt
+
+    xp_lines = xp.get_lines()
+    rs_lines = rs.get_lines()
+
+    assert len(xp_lines) == len(rs_lines)
+    for xpl, rsl in zip(xp_lines, rs_lines):
+        xpdata = xpl.get_xydata()
+        rsdata = rsl.get_xydata()
+        tm.assert_almost_equal(xpdata, rsdata)
+
+    plt.close("all")
+
+
+def _check_visible(collections, visible=True):
+    """
+    Check each artist is visible or not
+
+    Parameters
+    ----------
+    collections : matplotlib Artist or its list-like
+        target Artist or its list or collection
+    visible : bool
+        expected visibility
+    """
+    from matplotlib.collections import Collection
+
+    if not isinstance(collections, Collection) and not is_list_like(collections):
+        collections = [collections]
+
+    for patch in collections:
+        assert patch.get_visible() == visible
+
+
+def _check_patches_all_filled(axes: Axes | Sequence[Axes], filled: bool = True) -> None:
+    """
+    Check for each artist whether it is filled or not
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    filled : bool
+        expected filling
+    """
+
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        for patch in ax.patches:
+            assert patch.fill == filled
+
+
+def _get_colors_mapped(series, colors):
+    unique = series.unique()
+    # unique and colors length can be differed
+    # depending on slice value
+    mapped = dict(zip(unique, colors))
+    return [mapped[v] for v in series.values]
+
+
+def _check_colors(collections, linecolors=None, facecolors=None, mapping=None):
+    """
+    Check each artist has expected line colors and face colors
+
+    Parameters
+    ----------
+    collections : list-like
+        list or collection of target artist
+    linecolors : list-like which has the same length as collections
+        list of expected line colors
+    facecolors : list-like which has the same length as collections
+        list of expected face colors
+    mapping : Series
+        Series used for color grouping key
+        used for andrew_curves, parallel_coordinates, radviz test
+    """
+    from matplotlib import colors
+    from matplotlib.collections import (
+        Collection,
+        LineCollection,
+        PolyCollection,
+    )
+    from matplotlib.lines import Line2D
+
+    conv = colors.ColorConverter
+    if linecolors is not None:
+        if mapping is not None:
+            linecolors = _get_colors_mapped(mapping, linecolors)
+            linecolors = linecolors[: len(collections)]
+
+        assert len(collections) == len(linecolors)
+        for patch, color in zip(collections, linecolors):
+            if isinstance(patch, Line2D):
+                result = patch.get_color()
+                # Line2D may contains string color expression
+                result = conv.to_rgba(result)
+            elif isinstance(patch, (PolyCollection, LineCollection)):
+                result = tuple(patch.get_edgecolor()[0])
+            else:
+                result = patch.get_edgecolor()
+
+            expected = conv.to_rgba(color)
+            assert result == expected
+
+    if facecolors is not None:
+        if mapping is not None:
+            facecolors = _get_colors_mapped(mapping, facecolors)
+            facecolors = facecolors[: len(collections)]
+
+        assert len(collections) == len(facecolors)
+        for patch, color in zip(collections, facecolors):
+            if isinstance(patch, Collection):
+                # returned as list of np.array
+                result = patch.get_facecolor()[0]
+            else:
+                result = patch.get_facecolor()
+
+            if isinstance(result, np.ndarray):
+                result = tuple(result)
+
+            expected = conv.to_rgba(color)
+            assert result == expected
+
+
+def _check_text_labels(texts, expected):
+    """
+    Check each text has expected labels
+
+    Parameters
+    ----------
+    texts : matplotlib Text object, or its list-like
+        target text, or its list
+    expected : str or list-like which has the same length as texts
+        expected text label, or its list
+    """
+    if not is_list_like(texts):
+        assert texts.get_text() == expected
+    else:
+        labels = [t.get_text() for t in texts]
+        assert len(labels) == len(expected)
+        for label, e in zip(labels, expected):
+            assert label == e
+
+
+def _check_ticks_props(axes, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None):
+    """
+    Check each axes has expected tick properties
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    xlabelsize : number
+        expected xticks font size
+    xrot : number
+        expected xticks rotation
+    ylabelsize : number
+        expected yticks font size
+    yrot : number
+        expected yticks rotation
+    """
+    from matplotlib.ticker import NullFormatter
+
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        if xlabelsize is not None or xrot is not None:
+            if isinstance(ax.xaxis.get_minor_formatter(), NullFormatter):
+                # If minor ticks has NullFormatter, rot / fontsize are not
+                # retained
+                labels = ax.get_xticklabels()
+            else:
+                labels = ax.get_xticklabels() + ax.get_xticklabels(minor=True)
+
+            for label in labels:
+                if xlabelsize is not None:
+                    tm.assert_almost_equal(label.get_fontsize(), xlabelsize)
+                if xrot is not None:
+                    tm.assert_almost_equal(label.get_rotation(), xrot)
+
+        if ylabelsize is not None or yrot is not None:
+            if isinstance(ax.yaxis.get_minor_formatter(), NullFormatter):
+                labels = ax.get_yticklabels()
+            else:
+                labels = ax.get_yticklabels() + ax.get_yticklabels(minor=True)
+
+            for label in labels:
+                if ylabelsize is not None:
+                    tm.assert_almost_equal(label.get_fontsize(), ylabelsize)
+                if yrot is not None:
+                    tm.assert_almost_equal(label.get_rotation(), yrot)
+
+
+def _check_ax_scales(axes, xaxis="linear", yaxis="linear"):
+    """
+    Check each axes has expected scales
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    xaxis : {'linear', 'log'}
+        expected xaxis scale
+    yaxis : {'linear', 'log'}
+        expected yaxis scale
+    """
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        assert ax.xaxis.get_scale() == xaxis
+        assert ax.yaxis.get_scale() == yaxis
+
+
+def _check_axes_shape(axes, axes_num=None, layout=None, figsize=None):
+    """
+    Check expected number of axes is drawn in expected layout
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    axes_num : number
+        expected number of axes. Unnecessary axes should be set to
+        invisible.
+    layout : tuple
+        expected layout, (expected number of rows , columns)
+    figsize : tuple
+        expected figsize. default is matplotlib default
+    """
+    from pandas.plotting._matplotlib.tools import flatten_axes
+
+    if figsize is None:
+        figsize = (6.4, 4.8)
+    visible_axes = _flatten_visible(axes)
+
+    if axes_num is not None:
+        assert len(visible_axes) == axes_num
+        for ax in visible_axes:
+            # check something drawn on visible axes
+            assert len(ax.get_children()) > 0
+
+    if layout is not None:
+        x_set = set()
+        y_set = set()
+        for ax in flatten_axes(axes):
+            # check axes coordinates to estimate layout
+            points = ax.get_position().get_points()
+            x_set.add(points[0][0])
+            y_set.add(points[0][1])
+        result = (len(y_set), len(x_set))
+        assert result == layout
+
+    tm.assert_numpy_array_equal(
+        visible_axes[0].figure.get_size_inches(),
+        np.array(figsize, dtype=np.float64),
+    )
+
+
+def _flatten_visible(axes: Axes | Sequence[Axes]) -> Sequence[Axes]:
+    """
+    Flatten axes, and filter only visible
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+
+    """
+    from pandas.plotting._matplotlib.tools import flatten_axes
+
+    axes_ndarray = flatten_axes(axes)
+    axes = [ax for ax in axes_ndarray if ax.get_visible()]
+    return axes
+
+
+def _check_has_errorbars(axes, xerr=0, yerr=0):
+    """
+    Check axes has expected number of errorbars
+
+    Parameters
+    ----------
+    axes : matplotlib Axes object, or its list-like
+    xerr : number
+        expected number of x errorbar
+    yerr : number
+        expected number of y errorbar
+    """
+    axes = _flatten_visible(axes)
+    for ax in axes:
+        containers = ax.containers
+        xerr_count = 0
+        yerr_count = 0
+        for c in containers:
+            has_xerr = getattr(c, "has_xerr", False)
+            has_yerr = getattr(c, "has_yerr", False)
+            if has_xerr:
+                xerr_count += 1
+            if has_yerr:
+                yerr_count += 1
+        assert xerr == xerr_count
+        assert yerr == yerr_count
+
+
+def _check_box_return_type(
+    returned, return_type, expected_keys=None, check_ax_title=True
+):
+    """
+    Check box returned type is correct
+
+    Parameters
+    ----------
+    returned : object to be tested, returned from boxplot
+    return_type : str
+        return_type passed to boxplot
+    expected_keys : list-like, optional
+        group labels in subplot case. If not passed,
+        the function checks assuming boxplot uses single ax
+    check_ax_title : bool
+        Whether to check the ax.title is the same as expected_key
+        Intended to be checked by calling from ``boxplot``.
+        Normal ``plot`` doesn't attach ``ax.title``, it must be disabled.
+    """
+    from matplotlib.axes import Axes
+
+    types = {"dict": dict, "axes": Axes, "both": tuple}
+    if expected_keys is None:
+        # should be fixed when the returning default is changed
+        if return_type is None:
+            return_type = "dict"
+
+        assert isinstance(returned, types[return_type])
+        if return_type == "both":
+            assert isinstance(returned.ax, Axes)
+            assert isinstance(returned.lines, dict)
+    else:
+        # should be fixed when the returning default is changed
+        if return_type is None:
+            for r in _flatten_visible(returned):
+                assert isinstance(r, Axes)
+            return
+
+        assert isinstance(returned, Series)
+
+        assert sorted(returned.keys()) == sorted(expected_keys)
+        for key, value in returned.items():
+            assert isinstance(value, types[return_type])
+            # check returned dict has correct mapping
+            if return_type == "axes":
+                if check_ax_title:
+                    assert value.get_title() == key
+            elif return_type == "both":
+                if check_ax_title:
+                    assert value.ax.get_title() == key
+                assert isinstance(value.ax, Axes)
+                assert isinstance(value.lines, dict)
+            elif return_type == "dict":
+                line = value["medians"][0]
+                axes = line.axes
+                if check_ax_title:
+                    assert axes.get_title() == key
+            else:
+                raise AssertionError
+
+
+def _check_grid_settings(obj, kinds, kws={}):
+    # Make sure plot defaults to rcParams['axes.grid'] setting, GH 9792
+
+    import matplotlib as mpl
+
+    def is_grid_on():
+        xticks = mpl.pyplot.gca().xaxis.get_major_ticks()
+        yticks = mpl.pyplot.gca().yaxis.get_major_ticks()
+        xoff = all(not g.gridline.get_visible() for g in xticks)
+        yoff = all(not g.gridline.get_visible() for g in yticks)
+
+        return not (xoff and yoff)
+
+    spndx = 1
+    for kind in kinds:
+        mpl.pyplot.subplot(1, 4 * len(kinds), spndx)
+        spndx += 1
+        mpl.rc("axes", grid=False)
+        obj.plot(kind=kind, **kws)
+        assert not is_grid_on()
+        mpl.pyplot.clf()
+
+        mpl.pyplot.subplot(1, 4 * len(kinds), spndx)
+        spndx += 1
+        mpl.rc("axes", grid=True)
+        obj.plot(kind=kind, grid=False, **kws)
+        assert not is_grid_on()
+        mpl.pyplot.clf()
+
+        if kind not in ["pie", "hexbin", "scatter"]:
+            mpl.pyplot.subplot(1, 4 * len(kinds), spndx)
+            spndx += 1
+            mpl.rc("axes", grid=True)
+            obj.plot(kind=kind, **kws)
+            assert is_grid_on()
+            mpl.pyplot.clf()
+
+            mpl.pyplot.subplot(1, 4 * len(kinds), spndx)
+            spndx += 1
+            mpl.rc("axes", grid=False)
+            obj.plot(kind=kind, grid=True, **kws)
+            assert is_grid_on()
+            mpl.pyplot.clf()
+
+
+def _unpack_cycler(rcParams, field="color"):
+    """
+    Auxiliary function for correctly unpacking cycler after MPL >= 1.5
+    """
+    return [v[field] for v in rcParams["axes.prop_cycle"]]
+
+
+def get_x_axis(ax):
+    return ax._shared_axes["x"]
+
+
+def get_y_axis(ax):
+    return ax._shared_axes["y"]
+
+
+def _check_plot_works(f, default_axes=False, **kwargs):
+    """
+    Create plot and ensure that plot return object is valid.
+
+    Parameters
+    ----------
+    f : func
+        Plotting function.
+    default_axes : bool, optional
+        If False (default):
+            - If `ax` not in `kwargs`, then create subplot(211) and plot there
+            - Create new subplot(212) and plot there as well
+            - Mind special corner case for bootstrap_plot (see `_gen_two_subplots`)
+        If True:
+            - Simply run plotting function with kwargs provided
+            - All required axes instances will be created automatically
+            - It is recommended to use it when the plotting function
+            creates multiple axes itself. It helps avoid warnings like
+            'UserWarning: To output multiple subplots,
+            the figure containing the passed axes is being cleared'
+    **kwargs
+        Keyword arguments passed to the plotting function.
+
+    Returns
+    -------
+    Plot object returned by the last plotting.
+    """
+    import matplotlib.pyplot as plt
+
+    if default_axes:
+        gen_plots = _gen_default_plot
+    else:
+        gen_plots = _gen_two_subplots
+
+    ret = None
+    try:
+        fig = kwargs.get("figure", plt.gcf())
+        plt.clf()
+
+        for ret in gen_plots(f, fig, **kwargs):
+            tm.assert_is_valid_plot_return_object(ret)
+
+    finally:
+        plt.close(fig)
+
+    return ret
+
+
+def _gen_default_plot(f, fig, **kwargs):
+    """
+    Create plot in a default way.
+    """
+    yield f(**kwargs)
+
+
+def _gen_two_subplots(f, fig, **kwargs):
+    """
+    Create plot on two subplots forcefully created.
+    """
+    if "ax" not in kwargs:
+        fig.add_subplot(211)
+    yield f(**kwargs)
+
+    if f is pd.plotting.bootstrap_plot:
+        assert "ax" not in kwargs
+    else:
+        kwargs["ax"] = fig.add_subplot(212)
+    yield f(**kwargs)

llmeval-env/lib/python3.10/site-packages/pandas/tests/plotting/conftest.py

@@ -0,0 +1,56 @@
+import gc
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    to_datetime,
+)
+
+
+@pytest.fixture(autouse=True)
+def mpl_cleanup():
+    # matplotlib/testing/decorators.py#L24
+    # 1) Resets units registry
+    # 2) Resets rc_context
+    # 3) Closes all figures
+    mpl = pytest.importorskip("matplotlib")
+    mpl_units = pytest.importorskip("matplotlib.units")
+    plt = pytest.importorskip("matplotlib.pyplot")
+    orig_units_registry = mpl_units.registry.copy()
+    with mpl.rc_context():
+        mpl.use("template")
+        yield
+    mpl_units.registry.clear()
+    mpl_units.registry.update(orig_units_registry)
+    plt.close("all")
+    # https://matplotlib.org/stable/users/prev_whats_new/whats_new_3.6.0.html#garbage-collection-is-no-longer-run-on-figure-close  # noqa: E501
+    gc.collect(1)
+
+
+@pytest.fixture
+def hist_df():
+    n = 50
+    rng = np.random.default_rng(10)
+    gender = rng.choice(["Male", "Female"], size=n)
+    classroom = rng.choice(["A", "B", "C"], size=n)
+
+    hist_df = DataFrame(
+        {
+            "gender": gender,
+            "classroom": classroom,
+            "height": rng.normal(66, 4, size=n),
+            "weight": rng.normal(161, 32, size=n),
+            "category": rng.integers(4, size=n),
+            "datetime": to_datetime(
+                rng.integers(
+                    812419200000000000,
+                    819331200000000000,
+                    size=n,
+                    dtype=np.int64,
+                )
+            ),
+        }
+    )
+    return hist_df