Add files using upload-large-folder tool

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

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from pandas.compat._optional import import_optional_dependency
+
+import pandas as pd
+
+
+def _arrow_dtype_mapping() -> dict:
+    pa = import_optional_dependency("pyarrow")
+    return {
+        pa.int8(): pd.Int8Dtype(),
+        pa.int16(): pd.Int16Dtype(),
+        pa.int32(): pd.Int32Dtype(),
+        pa.int64(): pd.Int64Dtype(),
+        pa.uint8(): pd.UInt8Dtype(),
+        pa.uint16(): pd.UInt16Dtype(),
+        pa.uint32(): pd.UInt32Dtype(),
+        pa.uint64(): pd.UInt64Dtype(),
+        pa.bool_(): pd.BooleanDtype(),
+        pa.string(): pd.StringDtype(),
+        pa.float32(): pd.Float32Dtype(),
+        pa.float64(): pd.Float64Dtype(),
+    }
+
+
+def arrow_string_types_mapper() -> Callable:
+    pa = import_optional_dependency("pyarrow")
+
+    return {
+        pa.string(): pd.StringDtype(storage="pyarrow_numpy"),
+        pa.large_string(): pd.StringDtype(storage="pyarrow_numpy"),
+    }.get

env-llmeval/lib/python3.10/site-packages/pandas/io/clipboard/__init__.py

@@ -0,0 +1,747 @@
+"""
+Pyperclip
+
+A cross-platform clipboard module for Python,
+with copy & paste functions for plain text.
+By Al Sweigart [email protected]
+Licence at LICENSES/PYPERCLIP_LICENSE
+
+Usage:
+  import pyperclip
+  pyperclip.copy('The text to be copied to the clipboard.')
+  spam = pyperclip.paste()
+
+  if not pyperclip.is_available():
+    print("Copy functionality unavailable!")
+
+On Windows, no additional modules are needed.
+On Mac, the pyobjc module is used, falling back to the pbcopy and pbpaste cli
+    commands. (These commands should come with OS X.).
+On Linux, install xclip, xsel, or wl-clipboard (for "wayland" sessions) via
+package manager.
+For example, in Debian:
+    sudo apt-get install xclip
+    sudo apt-get install xsel
+    sudo apt-get install wl-clipboard
+
+Otherwise on Linux, you will need the PyQt5 modules installed.
+
+This module does not work with PyGObject yet.
+
+Cygwin is currently not supported.
+
+Security Note: This module runs programs with these names:
+    - pbcopy
+    - pbpaste
+    - xclip
+    - xsel
+    - wl-copy/wl-paste
+    - klipper
+    - qdbus
+A malicious user could rename or add programs with these names, tricking
+Pyperclip into running them with whatever permissions the Python process has.
+
+"""
+
+__version__ = "1.8.2"
+
+
+import contextlib
+import ctypes
+from ctypes import (
+    c_size_t,
+    c_wchar,
+    c_wchar_p,
+    get_errno,
+    sizeof,
+)
+import os
+import platform
+from shutil import which as _executable_exists
+import subprocess
+import time
+import warnings
+
+from pandas.errors import (
+    PyperclipException,
+    PyperclipWindowsException,
+)
+from pandas.util._exceptions import find_stack_level
+
+# `import PyQt4` sys.exit()s if DISPLAY is not in the environment.
+# Thus, we need to detect the presence of $DISPLAY manually
+# and not load PyQt4 if it is absent.
+HAS_DISPLAY = os.getenv("DISPLAY")
+
+EXCEPT_MSG = """
+    Pyperclip could not find a copy/paste mechanism for your system.
+    For more information, please visit
+    https://pyperclip.readthedocs.io/en/latest/index.html#not-implemented-error
+    """
+
+ENCODING = "utf-8"
+
+
+class PyperclipTimeoutException(PyperclipException):
+    pass
+
+
+def _stringifyText(text) -> str:
+    acceptedTypes = (str, int, float, bool)
+    if not isinstance(text, acceptedTypes):
+        raise PyperclipException(
+            f"only str, int, float, and bool values "
+            f"can be copied to the clipboard, not {type(text).__name__}"
+        )
+    return str(text)
+
+
+def init_osx_pbcopy_clipboard():
+    def copy_osx_pbcopy(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        with subprocess.Popen(
+            ["pbcopy", "w"], stdin=subprocess.PIPE, close_fds=True
+        ) as p:
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_osx_pbcopy():
+        with subprocess.Popen(
+            ["pbpaste", "r"], stdout=subprocess.PIPE, close_fds=True
+        ) as p:
+            stdout = p.communicate()[0]
+        return stdout.decode(ENCODING)
+
+    return copy_osx_pbcopy, paste_osx_pbcopy
+
+
+def init_osx_pyobjc_clipboard():
+    def copy_osx_pyobjc(text):
+        """Copy string argument to clipboard"""
+        text = _stringifyText(text)  # Converts non-str values to str.
+        newStr = Foundation.NSString.stringWithString_(text).nsstring()
+        newData = newStr.dataUsingEncoding_(Foundation.NSUTF8StringEncoding)
+        board = AppKit.NSPasteboard.generalPasteboard()
+        board.declareTypes_owner_([AppKit.NSStringPboardType], None)
+        board.setData_forType_(newData, AppKit.NSStringPboardType)
+
+    def paste_osx_pyobjc():
+        """Returns contents of clipboard"""
+        board = AppKit.NSPasteboard.generalPasteboard()
+        content = board.stringForType_(AppKit.NSStringPboardType)
+        return content
+
+    return copy_osx_pyobjc, paste_osx_pyobjc
+
+
+def init_qt_clipboard():
+    global QApplication
+    # $DISPLAY should exist
+
+    # Try to import from qtpy, but if that fails try PyQt5 then PyQt4
+    try:
+        from qtpy.QtWidgets import QApplication
+    except ImportError:
+        try:
+            from PyQt5.QtWidgets import QApplication
+        except ImportError:
+            from PyQt4.QtGui import QApplication
+
+    app = QApplication.instance()
+    if app is None:
+        app = QApplication([])
+
+    def copy_qt(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        cb = app.clipboard()
+        cb.setText(text)
+
+    def paste_qt() -> str:
+        cb = app.clipboard()
+        return str(cb.text())
+
+    return copy_qt, paste_qt
+
+
+def init_xclip_clipboard():
+    DEFAULT_SELECTION = "c"
+    PRIMARY_SELECTION = "p"
+
+    def copy_xclip(text, primary=False):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        selection = DEFAULT_SELECTION
+        if primary:
+            selection = PRIMARY_SELECTION
+        with subprocess.Popen(
+            ["xclip", "-selection", selection], stdin=subprocess.PIPE, close_fds=True
+        ) as p:
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_xclip(primary=False):
+        selection = DEFAULT_SELECTION
+        if primary:
+            selection = PRIMARY_SELECTION
+        with subprocess.Popen(
+            ["xclip", "-selection", selection, "-o"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            close_fds=True,
+        ) as p:
+            stdout = p.communicate()[0]
+        # Intentionally ignore extraneous output on stderr when clipboard is empty
+        return stdout.decode(ENCODING)
+
+    return copy_xclip, paste_xclip
+
+
+def init_xsel_clipboard():
+    DEFAULT_SELECTION = "-b"
+    PRIMARY_SELECTION = "-p"
+
+    def copy_xsel(text, primary=False):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        selection_flag = DEFAULT_SELECTION
+        if primary:
+            selection_flag = PRIMARY_SELECTION
+        with subprocess.Popen(
+            ["xsel", selection_flag, "-i"], stdin=subprocess.PIPE, close_fds=True
+        ) as p:
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_xsel(primary=False):
+        selection_flag = DEFAULT_SELECTION
+        if primary:
+            selection_flag = PRIMARY_SELECTION
+        with subprocess.Popen(
+            ["xsel", selection_flag, "-o"], stdout=subprocess.PIPE, close_fds=True
+        ) as p:
+            stdout = p.communicate()[0]
+        return stdout.decode(ENCODING)
+
+    return copy_xsel, paste_xsel
+
+
+def init_wl_clipboard():
+    PRIMARY_SELECTION = "-p"
+
+    def copy_wl(text, primary=False):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        args = ["wl-copy"]
+        if primary:
+            args.append(PRIMARY_SELECTION)
+        if not text:
+            args.append("--clear")
+            subprocess.check_call(args, close_fds=True)
+        else:
+            p = subprocess.Popen(args, stdin=subprocess.PIPE, close_fds=True)
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_wl(primary=False):
+        args = ["wl-paste", "-n"]
+        if primary:
+            args.append(PRIMARY_SELECTION)
+        p = subprocess.Popen(args, stdout=subprocess.PIPE, close_fds=True)
+        stdout, _stderr = p.communicate()
+        return stdout.decode(ENCODING)
+
+    return copy_wl, paste_wl
+
+
+def init_klipper_clipboard():
+    def copy_klipper(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        with subprocess.Popen(
+            [
+                "qdbus",
+                "org.kde.klipper",
+                "/klipper",
+                "setClipboardContents",
+                text.encode(ENCODING),
+            ],
+            stdin=subprocess.PIPE,
+            close_fds=True,
+        ) as p:
+            p.communicate(input=None)
+
+    def paste_klipper():
+        with subprocess.Popen(
+            ["qdbus", "org.kde.klipper", "/klipper", "getClipboardContents"],
+            stdout=subprocess.PIPE,
+            close_fds=True,
+        ) as p:
+            stdout = p.communicate()[0]
+
+        # Workaround for https://bugs.kde.org/show_bug.cgi?id=342874
+        # TODO: https://github.com/asweigart/pyperclip/issues/43
+        clipboardContents = stdout.decode(ENCODING)
+        # even if blank, Klipper will append a newline at the end
+        assert len(clipboardContents) > 0
+        # make sure that newline is there
+        assert clipboardContents.endswith("\n")
+        if clipboardContents.endswith("\n"):
+            clipboardContents = clipboardContents[:-1]
+        return clipboardContents
+
+    return copy_klipper, paste_klipper
+
+
+def init_dev_clipboard_clipboard():
+    def copy_dev_clipboard(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        if text == "":
+            warnings.warn(
+                "Pyperclip cannot copy a blank string to the clipboard on Cygwin. "
+                "This is effectively a no-op.",
+                stacklevel=find_stack_level(),
+            )
+        if "\r" in text:
+            warnings.warn(
+                "Pyperclip cannot handle \\r characters on Cygwin.",
+                stacklevel=find_stack_level(),
+            )
+
+        with open("/dev/clipboard", "w", encoding="utf-8") as fd:
+            fd.write(text)
+
+    def paste_dev_clipboard() -> str:
+        with open("/dev/clipboard", encoding="utf-8") as fd:
+            content = fd.read()
+        return content
+
+    return copy_dev_clipboard, paste_dev_clipboard
+
+
+def init_no_clipboard():
+    class ClipboardUnavailable:
+        def __call__(self, *args, **kwargs):
+            raise PyperclipException(EXCEPT_MSG)
+
+        def __bool__(self) -> bool:
+            return False
+
+    return ClipboardUnavailable(), ClipboardUnavailable()
+
+
+# Windows-related clipboard functions:
+class CheckedCall:
+    def __init__(self, f) -> None:
+        super().__setattr__("f", f)
+
+    def __call__(self, *args):
+        ret = self.f(*args)
+        if not ret and get_errno():
+            raise PyperclipWindowsException("Error calling " + self.f.__name__)
+        return ret
+
+    def __setattr__(self, key, value):
+        setattr(self.f, key, value)
+
+
+def init_windows_clipboard():
+    global HGLOBAL, LPVOID, DWORD, LPCSTR, INT
+    global HWND, HINSTANCE, HMENU, BOOL, UINT, HANDLE
+    from ctypes.wintypes import (
+        BOOL,
+        DWORD,
+        HANDLE,
+        HGLOBAL,
+        HINSTANCE,
+        HMENU,
+        HWND,
+        INT,
+        LPCSTR,
+        LPVOID,
+        UINT,
+    )
+
+    windll = ctypes.windll
+    msvcrt = ctypes.CDLL("msvcrt")
+
+    safeCreateWindowExA = CheckedCall(windll.user32.CreateWindowExA)
+    safeCreateWindowExA.argtypes = [
+        DWORD,
+        LPCSTR,
+        LPCSTR,
+        DWORD,
+        INT,
+        INT,
+        INT,
+        INT,
+        HWND,
+        HMENU,
+        HINSTANCE,
+        LPVOID,
+    ]
+    safeCreateWindowExA.restype = HWND
+
+    safeDestroyWindow = CheckedCall(windll.user32.DestroyWindow)
+    safeDestroyWindow.argtypes = [HWND]
+    safeDestroyWindow.restype = BOOL
+
+    OpenClipboard = windll.user32.OpenClipboard
+    OpenClipboard.argtypes = [HWND]
+    OpenClipboard.restype = BOOL
+
+    safeCloseClipboard = CheckedCall(windll.user32.CloseClipboard)
+    safeCloseClipboard.argtypes = []
+    safeCloseClipboard.restype = BOOL
+
+    safeEmptyClipboard = CheckedCall(windll.user32.EmptyClipboard)
+    safeEmptyClipboard.argtypes = []
+    safeEmptyClipboard.restype = BOOL
+
+    safeGetClipboardData = CheckedCall(windll.user32.GetClipboardData)
+    safeGetClipboardData.argtypes = [UINT]
+    safeGetClipboardData.restype = HANDLE
+
+    safeSetClipboardData = CheckedCall(windll.user32.SetClipboardData)
+    safeSetClipboardData.argtypes = [UINT, HANDLE]
+    safeSetClipboardData.restype = HANDLE
+
+    safeGlobalAlloc = CheckedCall(windll.kernel32.GlobalAlloc)
+    safeGlobalAlloc.argtypes = [UINT, c_size_t]
+    safeGlobalAlloc.restype = HGLOBAL
+
+    safeGlobalLock = CheckedCall(windll.kernel32.GlobalLock)
+    safeGlobalLock.argtypes = [HGLOBAL]
+    safeGlobalLock.restype = LPVOID
+
+    safeGlobalUnlock = CheckedCall(windll.kernel32.GlobalUnlock)
+    safeGlobalUnlock.argtypes = [HGLOBAL]
+    safeGlobalUnlock.restype = BOOL
+
+    wcslen = CheckedCall(msvcrt.wcslen)
+    wcslen.argtypes = [c_wchar_p]
+    wcslen.restype = UINT
+
+    GMEM_MOVEABLE = 0x0002
+    CF_UNICODETEXT = 13
+
+    @contextlib.contextmanager
+    def window():
+        """
+        Context that provides a valid Windows hwnd.
+        """
+        # we really just need the hwnd, so setting "STATIC"
+        # as predefined lpClass is just fine.
+        hwnd = safeCreateWindowExA(
+            0, b"STATIC", None, 0, 0, 0, 0, 0, None, None, None, None
+        )
+        try:
+            yield hwnd
+        finally:
+            safeDestroyWindow(hwnd)
+
+    @contextlib.contextmanager
+    def clipboard(hwnd):
+        """
+        Context manager that opens the clipboard and prevents
+        other applications from modifying the clipboard content.
+        """
+        # We may not get the clipboard handle immediately because
+        # some other application is accessing it (?)
+        # We try for at least 500ms to get the clipboard.
+        t = time.time() + 0.5
+        success = False
+        while time.time() < t:
+            success = OpenClipboard(hwnd)
+            if success:
+                break
+            time.sleep(0.01)
+        if not success:
+            raise PyperclipWindowsException("Error calling OpenClipboard")
+
+        try:
+            yield
+        finally:
+            safeCloseClipboard()
+
+    def copy_windows(text):
+        # This function is heavily based on
+        # http://msdn.com/ms649016#_win32_Copying_Information_to_the_Clipboard
+
+        text = _stringifyText(text)  # Converts non-str values to str.
+
+        with window() as hwnd:
+            # http://msdn.com/ms649048
+            # If an application calls OpenClipboard with hwnd set to NULL,
+            # EmptyClipboard sets the clipboard owner to NULL;
+            # this causes SetClipboardData to fail.
+            # => We need a valid hwnd to copy something.
+            with clipboard(hwnd):
+                safeEmptyClipboard()
+
+                if text:
+                    # http://msdn.com/ms649051
+                    # If the hMem parameter identifies a memory object,
+                    # the object must have been allocated using the
+                    # function with the GMEM_MOVEABLE flag.
+                    count = wcslen(text) + 1
+                    handle = safeGlobalAlloc(GMEM_MOVEABLE, count * sizeof(c_wchar))
+                    locked_handle = safeGlobalLock(handle)
+
+                    ctypes.memmove(
+                        c_wchar_p(locked_handle),
+                        c_wchar_p(text),
+                        count * sizeof(c_wchar),
+                    )
+
+                    safeGlobalUnlock(handle)
+                    safeSetClipboardData(CF_UNICODETEXT, handle)
+
+    def paste_windows():
+        with clipboard(None):
+            handle = safeGetClipboardData(CF_UNICODETEXT)
+            if not handle:
+                # GetClipboardData may return NULL with errno == NO_ERROR
+                # if the clipboard is empty.
+                # (Also, it may return a handle to an empty buffer,
+                # but technically that's not empty)
+                return ""
+            return c_wchar_p(handle).value
+
+    return copy_windows, paste_windows
+
+
+def init_wsl_clipboard():
+    def copy_wsl(text):
+        text = _stringifyText(text)  # Converts non-str values to str.
+        with subprocess.Popen(["clip.exe"], stdin=subprocess.PIPE, close_fds=True) as p:
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_wsl():
+        with subprocess.Popen(
+            ["powershell.exe", "-command", "Get-Clipboard"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            close_fds=True,
+        ) as p:
+            stdout = p.communicate()[0]
+        # WSL appends "\r\n" to the contents.
+        return stdout[:-2].decode(ENCODING)
+
+    return copy_wsl, paste_wsl
+
+
+# Automatic detection of clipboard mechanisms
+# and importing is done in determine_clipboard():
+def determine_clipboard():
+    """
+    Determine the OS/platform and set the copy() and paste() functions
+    accordingly.
+    """
+    global Foundation, AppKit, qtpy, PyQt4, PyQt5
+
+    # Setup for the CYGWIN platform:
+    if (
+        "cygwin" in platform.system().lower()
+    ):  # Cygwin has a variety of values returned by platform.system(),
+        # such as 'CYGWIN_NT-6.1'
+        # FIXME(pyperclip#55): pyperclip currently does not support Cygwin,
+        # see https://github.com/asweigart/pyperclip/issues/55
+        if os.path.exists("/dev/clipboard"):
+            warnings.warn(
+                "Pyperclip's support for Cygwin is not perfect, "
+                "see https://github.com/asweigart/pyperclip/issues/55",
+                stacklevel=find_stack_level(),
+            )
+            return init_dev_clipboard_clipboard()
+
+    # Setup for the WINDOWS platform:
+    elif os.name == "nt" or platform.system() == "Windows":
+        return init_windows_clipboard()
+
+    if platform.system() == "Linux":
+        if _executable_exists("wslconfig.exe"):
+            return init_wsl_clipboard()
+
+    # Setup for the macOS platform:
+    if os.name == "mac" or platform.system() == "Darwin":
+        try:
+            import AppKit
+            import Foundation  # check if pyobjc is installed
+        except ImportError:
+            return init_osx_pbcopy_clipboard()
+        else:
+            return init_osx_pyobjc_clipboard()
+
+    # Setup for the LINUX platform:
+    if HAS_DISPLAY:
+        if os.environ.get("WAYLAND_DISPLAY") and _executable_exists("wl-copy"):
+            return init_wl_clipboard()
+        if _executable_exists("xsel"):
+            return init_xsel_clipboard()
+        if _executable_exists("xclip"):
+            return init_xclip_clipboard()
+        if _executable_exists("klipper") and _executable_exists("qdbus"):
+            return init_klipper_clipboard()
+
+        try:
+            # qtpy is a small abstraction layer that lets you write applications
+            # using a single api call to either PyQt or PySide.
+            # https://pypi.python.org/project/QtPy
+            import qtpy  # check if qtpy is installed
+        except ImportError:
+            # If qtpy isn't installed, fall back on importing PyQt4.
+            try:
+                import PyQt5  # check if PyQt5 is installed
+            except ImportError:
+                try:
+                    import PyQt4  # check if PyQt4 is installed
+                except ImportError:
+                    pass  # We want to fail fast for all non-ImportError exceptions.
+                else:
+                    return init_qt_clipboard()
+            else:
+                return init_qt_clipboard()
+        else:
+            return init_qt_clipboard()
+
+    return init_no_clipboard()
+
+
+def set_clipboard(clipboard):
+    """
+    Explicitly sets the clipboard mechanism. The "clipboard mechanism" is how
+    the copy() and paste() functions interact with the operating system to
+    implement the copy/paste feature. The clipboard parameter must be one of:
+        - pbcopy
+        - pyobjc (default on macOS)
+        - qt
+        - xclip
+        - xsel
+        - klipper
+        - windows (default on Windows)
+        - no (this is what is set when no clipboard mechanism can be found)
+    """
+    global copy, paste
+
+    clipboard_types = {
+        "pbcopy": init_osx_pbcopy_clipboard,
+        "pyobjc": init_osx_pyobjc_clipboard,
+        "qt": init_qt_clipboard,  # TODO - split this into 'qtpy', 'pyqt4', and 'pyqt5'
+        "xclip": init_xclip_clipboard,
+        "xsel": init_xsel_clipboard,
+        "wl-clipboard": init_wl_clipboard,
+        "klipper": init_klipper_clipboard,
+        "windows": init_windows_clipboard,
+        "no": init_no_clipboard,
+    }
+
+    if clipboard not in clipboard_types:
+        allowed_clipboard_types = [repr(_) for _ in clipboard_types]
+        raise ValueError(
+            f"Argument must be one of {', '.join(allowed_clipboard_types)}"
+        )
+
+    # Sets pyperclip's copy() and paste() functions:
+    copy, paste = clipboard_types[clipboard]()
+
+
+def lazy_load_stub_copy(text):
+    """
+    A stub function for copy(), which will load the real copy() function when
+    called so that the real copy() function is used for later calls.
+
+    This allows users to import pyperclip without having determine_clipboard()
+    automatically run, which will automatically select a clipboard mechanism.
+    This could be a problem if it selects, say, the memory-heavy PyQt4 module
+    but the user was just going to immediately call set_clipboard() to use a
+    different clipboard mechanism.
+
+    The lazy loading this stub function implements gives the user a chance to
+    call set_clipboard() to pick another clipboard mechanism. Or, if the user
+    simply calls copy() or paste() without calling set_clipboard() first,
+    will fall back on whatever clipboard mechanism that determine_clipboard()
+    automatically chooses.
+    """
+    global copy, paste
+    copy, paste = determine_clipboard()
+    return copy(text)
+
+
+def lazy_load_stub_paste():
+    """
+    A stub function for paste(), which will load the real paste() function when
+    called so that the real paste() function is used for later calls.
+
+    This allows users to import pyperclip without having determine_clipboard()
+    automatically run, which will automatically select a clipboard mechanism.
+    This could be a problem if it selects, say, the memory-heavy PyQt4 module
+    but the user was just going to immediately call set_clipboard() to use a
+    different clipboard mechanism.
+
+    The lazy loading this stub function implements gives the user a chance to
+    call set_clipboard() to pick another clipboard mechanism. Or, if the user
+    simply calls copy() or paste() without calling set_clipboard() first,
+    will fall back on whatever clipboard mechanism that determine_clipboard()
+    automatically chooses.
+    """
+    global copy, paste
+    copy, paste = determine_clipboard()
+    return paste()
+
+
+def is_available() -> bool:
+    return copy != lazy_load_stub_copy and paste != lazy_load_stub_paste
+
+
+# Initially, copy() and paste() are set to lazy loading wrappers which will
+# set `copy` and `paste` to real functions the first time they're used, unless
+# set_clipboard() or determine_clipboard() is called first.
+copy, paste = lazy_load_stub_copy, lazy_load_stub_paste
+
+
+def waitForPaste(timeout=None):
+    """This function call blocks until a non-empty text string exists on the
+    clipboard. It returns this text.
+
+    This function raises PyperclipTimeoutException if timeout was set to
+    a number of seconds that has elapsed without non-empty text being put on
+    the clipboard."""
+    startTime = time.time()
+    while True:
+        clipboardText = paste()
+        if clipboardText != "":
+            return clipboardText
+        time.sleep(0.01)
+
+        if timeout is not None and time.time() > startTime + timeout:
+            raise PyperclipTimeoutException(
+                "waitForPaste() timed out after " + str(timeout) + " seconds."
+            )
+
+
+def waitForNewPaste(timeout=None):
+    """This function call blocks until a new text string exists on the
+    clipboard that is different from the text that was there when the function
+    was first called. It returns this text.
+
+    This function raises PyperclipTimeoutException if timeout was set to
+    a number of seconds that has elapsed without non-empty text being put on
+    the clipboard."""
+    startTime = time.time()
+    originalText = paste()
+    while True:
+        currentText = paste()
+        if currentText != originalText:
+            return currentText
+        time.sleep(0.01)
+
+        if timeout is not None and time.time() > startTime + timeout:
+            raise PyperclipTimeoutException(
+                "waitForNewPaste() timed out after " + str(timeout) + " seconds."
+            )
+
+
+__all__ = [
+    "copy",
+    "paste",
+    "waitForPaste",
+    "waitForNewPaste",
+    "set_clipboard",
+    "determine_clipboard",
+]
+
+# pandas aliases
+clipboard_get = paste
+clipboard_set = copy

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

@@ -0,0 +1,19 @@
+from pandas.io.excel._base import (
+    ExcelFile,
+    ExcelWriter,
+    read_excel,
+)
+from pandas.io.excel._odswriter import ODSWriter as _ODSWriter
+from pandas.io.excel._openpyxl import OpenpyxlWriter as _OpenpyxlWriter
+from pandas.io.excel._util import register_writer
+from pandas.io.excel._xlsxwriter import XlsxWriter as _XlsxWriter
+
+__all__ = ["read_excel", "ExcelWriter", "ExcelFile"]
+
+
+register_writer(_OpenpyxlWriter)
+
+register_writer(_XlsxWriter)
+
+
+register_writer(_ODSWriter)

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

@@ -0,0 +1,1659 @@
+from __future__ import annotations
+
+from collections.abc import (
+    Hashable,
+    Iterable,
+    Mapping,
+    Sequence,
+)
+import datetime
+from functools import partial
+from io import BytesIO
+import os
+from textwrap import fill
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Generic,
+    Literal,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+import warnings
+import zipfile
+
+from pandas._config import config
+
+from pandas._libs import lib
+from pandas._libs.parsers import STR_NA_VALUES
+from pandas.compat._optional import (
+    get_version,
+    import_optional_dependency,
+)
+from pandas.errors import EmptyDataError
+from pandas.util._decorators import (
+    Appender,
+    doc,
+)
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import check_dtype_backend
+
+from pandas.core.dtypes.common import (
+    is_bool,
+    is_float,
+    is_integer,
+    is_list_like,
+)
+
+from pandas.core.frame import DataFrame
+from pandas.core.shared_docs import _shared_docs
+from pandas.util.version import Version
+
+from pandas.io.common import (
+    IOHandles,
+    get_handle,
+    stringify_path,
+    validate_header_arg,
+)
+from pandas.io.excel._util import (
+    fill_mi_header,
+    get_default_engine,
+    get_writer,
+    maybe_convert_usecols,
+    pop_header_name,
+)
+from pandas.io.parsers import TextParser
+from pandas.io.parsers.readers import validate_integer
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from pandas._typing import (
+        DtypeArg,
+        DtypeBackend,
+        ExcelWriterIfSheetExists,
+        FilePath,
+        IntStrT,
+        ReadBuffer,
+        Self,
+        SequenceNotStr,
+        StorageOptions,
+        WriteExcelBuffer,
+    )
+_read_excel_doc = (
+    """
+Read an Excel file into a ``pandas`` ``DataFrame``.
+
+Supports `xls`, `xlsx`, `xlsm`, `xlsb`, `odf`, `ods` and `odt` file extensions
+read from a local filesystem or URL. Supports an option to read
+a single sheet or a list of sheets.
+
+Parameters
+----------
+io : str, bytes, ExcelFile, xlrd.Book, path object, or file-like object
+    Any valid string path is acceptable. The string could be a URL. Valid
+    URL schemes include http, ftp, s3, and file. For file URLs, a host is
+    expected. A local file could be: ``file://localhost/path/to/table.xlsx``.
+
+    If you want to pass in a path object, pandas accepts any ``os.PathLike``.
+
+    By file-like object, we refer to objects with a ``read()`` method,
+    such as a file handle (e.g. via builtin ``open`` function)
+    or ``StringIO``.
+
+    .. deprecated:: 2.1.0
+        Passing byte strings is deprecated. To read from a
+        byte string, wrap it in a ``BytesIO`` object.
+sheet_name : str, int, list, or None, default 0
+    Strings are used for sheet names. Integers are used in zero-indexed
+    sheet positions (chart sheets do not count as a sheet position).
+    Lists of strings/integers are used to request multiple sheets.
+    Specify ``None`` to get all worksheets.
+
+    Available cases:
+
+    * Defaults to ``0``: 1st sheet as a `DataFrame`
+    * ``1``: 2nd sheet as a `DataFrame`
+    * ``"Sheet1"``: Load sheet with name "Sheet1"
+    * ``[0, 1, "Sheet5"]``: Load first, second and sheet named "Sheet5"
+      as a dict of `DataFrame`
+    * ``None``: All worksheets.
+
+header : int, list of int, default 0
+    Row (0-indexed) to use for the column labels of the parsed
+    DataFrame. If a list of integers is passed those row positions will
+    be combined into a ``MultiIndex``. Use None if there is no header.
+names : array-like, default None
+    List of column names to use. If file contains no header row,
+    then you should explicitly pass header=None.
+index_col : int, str, list of int, default None
+    Column (0-indexed) to use as the row labels of the DataFrame.
+    Pass None if there is no such column.  If a list is passed,
+    those columns will be combined into a ``MultiIndex``.  If a
+    subset of data is selected with ``usecols``, index_col
+    is based on the subset.
+
+    Missing values will be forward filled to allow roundtripping with
+    ``to_excel`` for ``merged_cells=True``. To avoid forward filling the
+    missing values use ``set_index`` after reading the data instead of
+    ``index_col``.
+usecols : str, list-like, or callable, default None
+    * If None, then parse all columns.
+    * If str, then indicates comma separated list of Excel column letters
+      and column ranges (e.g. "A:E" or "A,C,E:F"). Ranges are inclusive of
+      both sides.
+    * If list of int, then indicates list of column numbers to be parsed
+      (0-indexed).
+    * If list of string, then indicates list of column names to be parsed.
+    * If callable, then evaluate each column name against it and parse the
+      column if the callable returns ``True``.
+
+    Returns a subset of the columns according to behavior above.
+dtype : Type name or dict of column -> type, default None
+    Data type for data or columns. E.g. {{'a': np.float64, 'b': np.int32}}
+    Use ``object`` to preserve data as stored in Excel and not interpret dtype,
+    which will necessarily result in ``object`` dtype.
+    If converters are specified, they will be applied INSTEAD
+    of dtype conversion.
+    If you use ``None``, it will infer the dtype of each column based on the data.
+engine : {{'openpyxl', 'calamine', 'odf', 'pyxlsb', 'xlrd'}}, default None
+    If io is not a buffer or path, this must be set to identify io.
+    Engine compatibility :
+
+    - ``openpyxl`` supports newer Excel file formats.
+    - ``calamine`` supports Excel (.xls, .xlsx, .xlsm, .xlsb)
+      and OpenDocument (.ods) file formats.
+    - ``odf`` supports OpenDocument file formats (.odf, .ods, .odt).
+    - ``pyxlsb`` supports Binary Excel files.
+    - ``xlrd`` supports old-style Excel files (.xls).
+
+    When ``engine=None``, the following logic will be used to determine the engine:
+
+    - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),
+      then `odf <https://pypi.org/project/odfpy/>`_ will be used.
+    - Otherwise if ``path_or_buffer`` is an xls format, ``xlrd`` will be used.
+    - Otherwise if ``path_or_buffer`` is in xlsb format, ``pyxlsb`` will be used.
+    - Otherwise ``openpyxl`` will be used.
+converters : dict, default None
+    Dict of functions for converting values in certain columns. Keys can
+    either be integers or column labels, values are functions that take one
+    input argument, the Excel cell content, and return the transformed
+    content.
+true_values : list, default None
+    Values to consider as True.
+false_values : list, default None
+    Values to consider as False.
+skiprows : list-like, int, or callable, optional
+    Line numbers to skip (0-indexed) or number of lines to skip (int) at the
+    start of the file. If callable, the callable function will be evaluated
+    against the row indices, returning True if the row should be skipped and
+    False otherwise. An example of a valid callable argument would be ``lambda
+    x: x in [0, 2]``.
+nrows : int, default None
+    Number of rows to parse.
+na_values : scalar, str, list-like, or dict, default None
+    Additional strings to recognize as NA/NaN. If dict passed, specific
+    per-column NA values. By default the following values are interpreted
+    as NaN: '"""
+    + fill("', '".join(sorted(STR_NA_VALUES)), 70, subsequent_indent="    ")
+    + """'.
+keep_default_na : bool, default True
+    Whether or not to include the default NaN values when parsing the data.
+    Depending on whether ``na_values`` is passed in, the behavior is as follows:
+
+    * If ``keep_default_na`` is True, and ``na_values`` are specified,
+      ``na_values`` is appended to the default NaN values used for parsing.
+    * If ``keep_default_na`` is True, and ``na_values`` are not specified, only
+      the default NaN values are used for parsing.
+    * If ``keep_default_na`` is False, and ``na_values`` are specified, only
+      the NaN values specified ``na_values`` are used for parsing.
+    * If ``keep_default_na`` is False, and ``na_values`` are not specified, no
+      strings will be parsed as NaN.
+
+    Note that if `na_filter` is passed in as False, the ``keep_default_na`` and
+    ``na_values`` parameters will be ignored.
+na_filter : bool, default True
+    Detect missing value markers (empty strings and the value of na_values). In
+    data without any NAs, passing ``na_filter=False`` can improve the
+    performance of reading a large file.
+verbose : bool, default False
+    Indicate number of NA values placed in non-numeric columns.
+parse_dates : bool, list-like, or dict, default False
+    The behavior is as follows:
+
+    * ``bool``. If True -> try parsing the index.
+    * ``list`` of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3
+      each as a separate date column.
+    * ``list`` of lists. e.g.  If [[1, 3]] -> combine columns 1 and 3 and parse as
+      a single date column.
+    * ``dict``, e.g. {{'foo' : [1, 3]}} -> parse columns 1, 3 as date and call
+      result 'foo'
+
+    If a column or index contains an unparsable date, the entire column or
+    index will be returned unaltered as an object data type. If you don`t want to
+    parse some cells as date just change their type in Excel to "Text".
+    For non-standard datetime parsing, use ``pd.to_datetime`` after ``pd.read_excel``.
+
+    Note: A fast-path exists for iso8601-formatted dates.
+date_parser : function, optional
+    Function to use for converting a sequence of string columns to an array of
+    datetime instances. The default uses ``dateutil.parser.parser`` to do the
+    conversion. Pandas will try to call `date_parser` in three different ways,
+    advancing to the next if an exception occurs: 1) Pass one or more arrays
+    (as defined by `parse_dates`) as arguments; 2) concatenate (row-wise) the
+    string values from the columns defined by `parse_dates` into a single array
+    and pass that; and 3) call `date_parser` once for each row using one or
+    more strings (corresponding to the columns defined by `parse_dates`) as
+    arguments.
+
+    .. deprecated:: 2.0.0
+       Use ``date_format`` instead, or read in as ``object`` and then apply
+       :func:`to_datetime` as-needed.
+date_format : str or dict of column -> format, default ``None``
+   If used in conjunction with ``parse_dates``, will parse dates according to this
+   format. For anything more complex,
+   please read in as ``object`` and then apply :func:`to_datetime` as-needed.
+
+   .. versionadded:: 2.0.0
+thousands : str, default None
+    Thousands separator for parsing string columns to numeric.  Note that
+    this parameter is only necessary for columns stored as TEXT in Excel,
+    any numeric columns will automatically be parsed, regardless of display
+    format.
+decimal : str, default '.'
+    Character to recognize as decimal point for parsing string columns to numeric.
+    Note that this parameter is only necessary for columns stored as TEXT in Excel,
+    any numeric columns will automatically be parsed, regardless of display
+    format.(e.g. use ',' for European data).
+
+    .. versionadded:: 1.4.0
+
+comment : str, default None
+    Comments out remainder of line. Pass a character or characters to this
+    argument to indicate comments in the input file. Any data between the
+    comment string and the end of the current line is ignored.
+skipfooter : int, default 0
+    Rows at the end to skip (0-indexed).
+{storage_options}
+
+dtype_backend : {{'numpy_nullable', 'pyarrow'}}, default 'numpy_nullable'
+    Back-end data type applied to the resultant :class:`DataFrame`
+    (still experimental). Behaviour is as follows:
+
+    * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
+      (default).
+    * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
+      DataFrame.
+
+    .. versionadded:: 2.0
+
+engine_kwargs : dict, optional
+    Arbitrary keyword arguments passed to excel engine.
+
+Returns
+-------
+DataFrame or dict of DataFrames
+    DataFrame from the passed in Excel file. See notes in sheet_name
+    argument for more information on when a dict of DataFrames is returned.
+
+See Also
+--------
+DataFrame.to_excel : Write DataFrame to an Excel file.
+DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
+read_csv : Read a comma-separated values (csv) file into DataFrame.
+read_fwf : Read a table of fixed-width formatted lines into DataFrame.
+
+Notes
+-----
+For specific information on the methods used for each Excel engine, refer to the pandas
+:ref:`user guide <io.excel_reader>`
+
+Examples
+--------
+The file can be read using the file name as string or an open file object:
+
+>>> pd.read_excel('tmp.xlsx', index_col=0)  # doctest: +SKIP
+       Name  Value
+0   string1      1
+1   string2      2
+2  #Comment      3
+
+>>> pd.read_excel(open('tmp.xlsx', 'rb'),
+...               sheet_name='Sheet3')  # doctest: +SKIP
+   Unnamed: 0      Name  Value
+0           0   string1      1
+1           1   string2      2
+2           2  #Comment      3
+
+Index and header can be specified via the `index_col` and `header` arguments
+
+>>> pd.read_excel('tmp.xlsx', index_col=None, header=None)  # doctest: +SKIP
+     0         1      2
+0  NaN      Name  Value
+1  0.0   string1      1
+2  1.0   string2      2
+3  2.0  #Comment      3
+
+Column types are inferred but can be explicitly specified
+
+>>> pd.read_excel('tmp.xlsx', index_col=0,
+...               dtype={{'Name': str, 'Value': float}})  # doctest: +SKIP
+       Name  Value
+0   string1    1.0
+1   string2    2.0
+2  #Comment    3.0
+
+True, False, and NA values, and thousands separators have defaults,
+but can be explicitly specified, too. Supply the values you would like
+as strings or lists of strings!
+
+>>> pd.read_excel('tmp.xlsx', index_col=0,
+...               na_values=['string1', 'string2'])  # doctest: +SKIP
+       Name  Value
+0       NaN      1
+1       NaN      2
+2  #Comment      3
+
+Comment lines in the excel input file can be skipped using the
+``comment`` kwarg.
+
+>>> pd.read_excel('tmp.xlsx', index_col=0, comment='#')  # doctest: +SKIP
+      Name  Value
+0  string1    1.0
+1  string2    2.0
+2     None    NaN
+"""
+)
+
+
+@overload
+def read_excel(
+    io,
+    # sheet name is str or int -> DataFrame
+    sheet_name: str | int = ...,
+    *,
+    header: int | Sequence[int] | None = ...,
+    names: SequenceNotStr[Hashable] | range | None = ...,
+    index_col: int | str | Sequence[int] | None = ...,
+    usecols: int
+    | str
+    | Sequence[int]
+    | Sequence[str]
+    | Callable[[str], bool]
+    | None = ...,
+    dtype: DtypeArg | None = ...,
+    engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb", "calamine"] | None = ...,
+    converters: dict[str, Callable] | dict[int, Callable] | None = ...,
+    true_values: Iterable[Hashable] | None = ...,
+    false_values: Iterable[Hashable] | None = ...,
+    skiprows: Sequence[int] | int | Callable[[int], object] | None = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    parse_dates: list | dict | bool = ...,
+    date_parser: Callable | lib.NoDefault = ...,
+    date_format: dict[Hashable, str] | str | None = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    comment: str | None = ...,
+    skipfooter: int = ...,
+    storage_options: StorageOptions = ...,
+    dtype_backend: DtypeBackend | lib.NoDefault = ...,
+) -> DataFrame:
+    ...
+
+
+@overload
+def read_excel(
+    io,
+    # sheet name is list or None -> dict[IntStrT, DataFrame]
+    sheet_name: list[IntStrT] | None,
+    *,
+    header: int | Sequence[int] | None = ...,
+    names: SequenceNotStr[Hashable] | range | None = ...,
+    index_col: int | str | Sequence[int] | None = ...,
+    usecols: int
+    | str
+    | Sequence[int]
+    | Sequence[str]
+    | Callable[[str], bool]
+    | None = ...,
+    dtype: DtypeArg | None = ...,
+    engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb", "calamine"] | None = ...,
+    converters: dict[str, Callable] | dict[int, Callable] | None = ...,
+    true_values: Iterable[Hashable] | None = ...,
+    false_values: Iterable[Hashable] | None = ...,
+    skiprows: Sequence[int] | int | Callable[[int], object] | None = ...,
+    nrows: int | None = ...,
+    na_values=...,
+    keep_default_na: bool = ...,
+    na_filter: bool = ...,
+    verbose: bool = ...,
+    parse_dates: list | dict | bool = ...,
+    date_parser: Callable | lib.NoDefault = ...,
+    date_format: dict[Hashable, str] | str | None = ...,
+    thousands: str | None = ...,
+    decimal: str = ...,
+    comment: str | None = ...,
+    skipfooter: int = ...,
+    storage_options: StorageOptions = ...,
+    dtype_backend: DtypeBackend | lib.NoDefault = ...,
+) -> dict[IntStrT, DataFrame]:
+    ...
+
+
+@doc(storage_options=_shared_docs["storage_options"])
+@Appender(_read_excel_doc)
+def read_excel(
+    io,
+    sheet_name: str | int | list[IntStrT] | None = 0,
+    *,
+    header: int | Sequence[int] | None = 0,
+    names: SequenceNotStr[Hashable] | range | None = None,
+    index_col: int | str | Sequence[int] | None = None,
+    usecols: int
+    | str
+    | Sequence[int]
+    | Sequence[str]
+    | Callable[[str], bool]
+    | None = None,
+    dtype: DtypeArg | None = None,
+    engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb", "calamine"] | None = None,
+    converters: dict[str, Callable] | dict[int, Callable] | None = None,
+    true_values: Iterable[Hashable] | None = None,
+    false_values: Iterable[Hashable] | None = None,
+    skiprows: Sequence[int] | int | Callable[[int], object] | None = None,
+    nrows: int | None = None,
+    na_values=None,
+    keep_default_na: bool = True,
+    na_filter: bool = True,
+    verbose: bool = False,
+    parse_dates: list | dict | bool = False,
+    date_parser: Callable | lib.NoDefault = lib.no_default,
+    date_format: dict[Hashable, str] | str | None = None,
+    thousands: str | None = None,
+    decimal: str = ".",
+    comment: str | None = None,
+    skipfooter: int = 0,
+    storage_options: StorageOptions | None = None,
+    dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
+    engine_kwargs: dict | None = None,
+) -> DataFrame | dict[IntStrT, DataFrame]:
+    check_dtype_backend(dtype_backend)
+    should_close = False
+    if engine_kwargs is None:
+        engine_kwargs = {}
+
+    if not isinstance(io, ExcelFile):
+        should_close = True
+        io = ExcelFile(
+            io,
+            storage_options=storage_options,
+            engine=engine,
+            engine_kwargs=engine_kwargs,
+        )
+    elif engine and engine != io.engine:
+        raise ValueError(
+            "Engine should not be specified when passing "
+            "an ExcelFile - ExcelFile already has the engine set"
+        )
+
+    try:
+        data = io.parse(
+            sheet_name=sheet_name,
+            header=header,
+            names=names,
+            index_col=index_col,
+            usecols=usecols,
+            dtype=dtype,
+            converters=converters,
+            true_values=true_values,
+            false_values=false_values,
+            skiprows=skiprows,
+            nrows=nrows,
+            na_values=na_values,
+            keep_default_na=keep_default_na,
+            na_filter=na_filter,
+            verbose=verbose,
+            parse_dates=parse_dates,
+            date_parser=date_parser,
+            date_format=date_format,
+            thousands=thousands,
+            decimal=decimal,
+            comment=comment,
+            skipfooter=skipfooter,
+            dtype_backend=dtype_backend,
+        )
+    finally:
+        # make sure to close opened file handles
+        if should_close:
+            io.close()
+    return data
+
+
+_WorkbookT = TypeVar("_WorkbookT")
+
+
+class BaseExcelReader(Generic[_WorkbookT]):
+    book: _WorkbookT
+
+    def __init__(
+        self,
+        filepath_or_buffer,
+        storage_options: StorageOptions | None = None,
+        engine_kwargs: dict | None = None,
+    ) -> None:
+        if engine_kwargs is None:
+            engine_kwargs = {}
+
+        # First argument can also be bytes, so create a buffer
+        if isinstance(filepath_or_buffer, bytes):
+            filepath_or_buffer = BytesIO(filepath_or_buffer)
+
+        self.handles = IOHandles(
+            handle=filepath_or_buffer, compression={"method": None}
+        )
+        if not isinstance(filepath_or_buffer, (ExcelFile, self._workbook_class)):
+            self.handles = get_handle(
+                filepath_or_buffer, "rb", storage_options=storage_options, is_text=False
+            )
+
+        if isinstance(self.handles.handle, self._workbook_class):
+            self.book = self.handles.handle
+        elif hasattr(self.handles.handle, "read"):
+            # N.B. xlrd.Book has a read attribute too
+            self.handles.handle.seek(0)
+            try:
+                self.book = self.load_workbook(self.handles.handle, engine_kwargs)
+            except Exception:
+                self.close()
+                raise
+        else:
+            raise ValueError(
+                "Must explicitly set engine if not passing in buffer or path for io."
+            )
+
+    @property
+    def _workbook_class(self) -> type[_WorkbookT]:
+        raise NotImplementedError
+
+    def load_workbook(self, filepath_or_buffer, engine_kwargs) -> _WorkbookT:
+        raise NotImplementedError
+
+    def close(self) -> None:
+        if hasattr(self, "book"):
+            if hasattr(self.book, "close"):
+                # pyxlsb: opens a TemporaryFile
+                # openpyxl: https://stackoverflow.com/questions/31416842/
+                #     openpyxl-does-not-close-excel-workbook-in-read-only-mode
+                self.book.close()
+            elif hasattr(self.book, "release_resources"):
+                # xlrd
+                # https://github.com/python-excel/xlrd/blob/2.0.1/xlrd/book.py#L548
+                self.book.release_resources()
+        self.handles.close()
+
+    @property
+    def sheet_names(self) -> list[str]:
+        raise NotImplementedError
+
+    def get_sheet_by_name(self, name: str):
+        raise NotImplementedError
+
+    def get_sheet_by_index(self, index: int):
+        raise NotImplementedError
+
+    def get_sheet_data(self, sheet, rows: int | None = None):
+        raise NotImplementedError
+
+    def raise_if_bad_sheet_by_index(self, index: int) -> None:
+        n_sheets = len(self.sheet_names)
+        if index >= n_sheets:
+            raise ValueError(
+                f"Worksheet index {index} is invalid, {n_sheets} worksheets found"
+            )
+
+    def raise_if_bad_sheet_by_name(self, name: str) -> None:
+        if name not in self.sheet_names:
+            raise ValueError(f"Worksheet named '{name}' not found")
+
+    def _check_skiprows_func(
+        self,
+        skiprows: Callable,
+        rows_to_use: int,
+    ) -> int:
+        """
+        Determine how many file rows are required to obtain `nrows` data
+        rows when `skiprows` is a function.
+
+        Parameters
+        ----------
+        skiprows : function
+            The function passed to read_excel by the user.
+        rows_to_use : int
+            The number of rows that will be needed for the header and
+            the data.
+
+        Returns
+        -------
+        int
+        """
+        i = 0
+        rows_used_so_far = 0
+        while rows_used_so_far < rows_to_use:
+            if not skiprows(i):
+                rows_used_so_far += 1
+            i += 1
+        return i
+
+    def _calc_rows(
+        self,
+        header: int | Sequence[int] | None,
+        index_col: int | Sequence[int] | None,
+        skiprows: Sequence[int] | int | Callable[[int], object] | None,
+        nrows: int | None,
+    ) -> int | None:
+        """
+        If nrows specified, find the number of rows needed from the
+        file, otherwise return None.
+
+
+        Parameters
+        ----------
+        header : int, list of int, or None
+            See read_excel docstring.
+        index_col : int, str, list of int, or None
+            See read_excel docstring.
+        skiprows : list-like, int, callable, or None
+            See read_excel docstring.
+        nrows : int or None
+            See read_excel docstring.
+
+        Returns
+        -------
+        int or None
+        """
+        if nrows is None:
+            return None
+        if header is None:
+            header_rows = 1
+        elif is_integer(header):
+            header = cast(int, header)
+            header_rows = 1 + header
+        else:
+            header = cast(Sequence, header)
+            header_rows = 1 + header[-1]
+        # If there is a MultiIndex header and an index then there is also
+        # a row containing just the index name(s)
+        if is_list_like(header) and index_col is not None:
+            header = cast(Sequence, header)
+            if len(header) > 1:
+                header_rows += 1
+        if skiprows is None:
+            return header_rows + nrows
+        if is_integer(skiprows):
+            skiprows = cast(int, skiprows)
+            return header_rows + nrows + skiprows
+        if is_list_like(skiprows):
+
+            def f(skiprows: Sequence, x: int) -> bool:
+                return x in skiprows
+
+            skiprows = cast(Sequence, skiprows)
+            return self._check_skiprows_func(partial(f, skiprows), header_rows + nrows)
+        if callable(skiprows):
+            return self._check_skiprows_func(
+                skiprows,
+                header_rows + nrows,
+            )
+        # else unexpected skiprows type: read_excel will not optimize
+        # the number of rows read from file
+        return None
+
+    def parse(
+        self,
+        sheet_name: str | int | list[int] | list[str] | None = 0,
+        header: int | Sequence[int] | None = 0,
+        names: SequenceNotStr[Hashable] | range | None = None,
+        index_col: int | Sequence[int] | None = None,
+        usecols=None,
+        dtype: DtypeArg | None = None,
+        true_values: Iterable[Hashable] | None = None,
+        false_values: Iterable[Hashable] | None = None,
+        skiprows: Sequence[int] | int | Callable[[int], object] | None = None,
+        nrows: int | None = None,
+        na_values=None,
+        verbose: bool = False,
+        parse_dates: list | dict | bool = False,
+        date_parser: Callable | lib.NoDefault = lib.no_default,
+        date_format: dict[Hashable, str] | str | None = None,
+        thousands: str | None = None,
+        decimal: str = ".",
+        comment: str | None = None,
+        skipfooter: int = 0,
+        dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
+        **kwds,
+    ):
+        validate_header_arg(header)
+        validate_integer("nrows", nrows)
+
+        ret_dict = False
+
+        # Keep sheetname to maintain backwards compatibility.
+        sheets: list[int] | list[str]
+        if isinstance(sheet_name, list):
+            sheets = sheet_name
+            ret_dict = True
+        elif sheet_name is None:
+            sheets = self.sheet_names
+            ret_dict = True
+        elif isinstance(sheet_name, str):
+            sheets = [sheet_name]
+        else:
+            sheets = [sheet_name]
+
+        # handle same-type duplicates.
+        sheets = cast(Union[list[int], list[str]], list(dict.fromkeys(sheets).keys()))
+
+        output = {}
+
+        last_sheetname = None
+        for asheetname in sheets:
+            last_sheetname = asheetname
+            if verbose:
+                print(f"Reading sheet {asheetname}")
+
+            if isinstance(asheetname, str):
+                sheet = self.get_sheet_by_name(asheetname)
+            else:  # assume an integer if not a string
+                sheet = self.get_sheet_by_index(asheetname)
+
+            file_rows_needed = self._calc_rows(header, index_col, skiprows, nrows)
+            data = self.get_sheet_data(sheet, file_rows_needed)
+            if hasattr(sheet, "close"):
+                # pyxlsb opens two TemporaryFiles
+                sheet.close()
+            usecols = maybe_convert_usecols(usecols)
+
+            if not data:
+                output[asheetname] = DataFrame()
+                continue
+
+            is_list_header = False
+            is_len_one_list_header = False
+            if is_list_like(header):
+                assert isinstance(header, Sequence)
+                is_list_header = True
+                if len(header) == 1:
+                    is_len_one_list_header = True
+
+            if is_len_one_list_header:
+                header = cast(Sequence[int], header)[0]
+
+            # forward fill and pull out names for MultiIndex column
+            header_names = None
+            if header is not None and is_list_like(header):
+                assert isinstance(header, Sequence)
+
+                header_names = []
+                control_row = [True] * len(data[0])
+
+                for row in header:
+                    if is_integer(skiprows):
+                        assert isinstance(skiprows, int)
+                        row += skiprows
+
+                    if row > len(data) - 1:
+                        raise ValueError(
+                            f"header index {row} exceeds maximum index "
+                            f"{len(data) - 1} of data.",
+                        )
+
+                    data[row], control_row = fill_mi_header(data[row], control_row)
+
+                    if index_col is not None:
+                        header_name, _ = pop_header_name(data[row], index_col)
+                        header_names.append(header_name)
+
+            # If there is a MultiIndex header and an index then there is also
+            # a row containing just the index name(s)
+            has_index_names = False
+            if is_list_header and not is_len_one_list_header and index_col is not None:
+                index_col_list: Sequence[int]
+                if isinstance(index_col, int):
+                    index_col_list = [index_col]
+                else:
+                    assert isinstance(index_col, Sequence)
+                    index_col_list = index_col
+
+                # We have to handle mi without names. If any of the entries in the data
+                # columns are not empty, this is a regular row
+                assert isinstance(header, Sequence)
+                if len(header) < len(data):
+                    potential_index_names = data[len(header)]
+                    potential_data = [
+                        x
+                        for i, x in enumerate(potential_index_names)
+                        if not control_row[i] and i not in index_col_list
+                    ]
+                    has_index_names = all(x == "" or x is None for x in potential_data)
+
+            if is_list_like(index_col):
+                # Forward fill values for MultiIndex index.
+                if header is None:
+                    offset = 0
+                elif isinstance(header, int):
+                    offset = 1 + header
+                else:
+                    offset = 1 + max(header)
+
+                # GH34673: if MultiIndex names present and not defined in the header,
+                # offset needs to be incremented so that forward filling starts
+                # from the first MI value instead of the name
+                if has_index_names:
+                    offset += 1
+
+                # Check if we have an empty dataset
+                # before trying to collect data.
+                if offset < len(data):
+                    assert isinstance(index_col, Sequence)
+
+                    for col in index_col:
+                        last = data[offset][col]
+
+                        for row in range(offset + 1, len(data)):
+                            if data[row][col] == "" or data[row][col] is None:
+                                data[row][col] = last
+                            else:
+                                last = data[row][col]
+
+            # GH 12292 : error when read one empty column from excel file
+            try:
+                parser = TextParser(
+                    data,
+                    names=names,
+                    header=header,
+                    index_col=index_col,
+                    has_index_names=has_index_names,
+                    dtype=dtype,
+                    true_values=true_values,
+                    false_values=false_values,
+                    skiprows=skiprows,
+                    nrows=nrows,
+                    na_values=na_values,
+                    skip_blank_lines=False,  # GH 39808
+                    parse_dates=parse_dates,
+                    date_parser=date_parser,
+                    date_format=date_format,
+                    thousands=thousands,
+                    decimal=decimal,
+                    comment=comment,
+                    skipfooter=skipfooter,
+                    usecols=usecols,
+                    dtype_backend=dtype_backend,
+                    **kwds,
+                )
+
+                output[asheetname] = parser.read(nrows=nrows)
+
+                if header_names:
+                    output[asheetname].columns = output[asheetname].columns.set_names(
+                        header_names
+                    )
+
+            except EmptyDataError:
+                # No Data, return an empty DataFrame
+                output[asheetname] = DataFrame()
+
+            except Exception as err:
+                err.args = (f"{err.args[0]} (sheet: {asheetname})", *err.args[1:])
+                raise err
+
+        if last_sheetname is None:
+            raise ValueError("Sheet name is an empty list")
+
+        if ret_dict:
+            return output
+        else:
+            return output[last_sheetname]
+
+
+@doc(storage_options=_shared_docs["storage_options"])
+class ExcelWriter(Generic[_WorkbookT]):
+    """
+    Class for writing DataFrame objects into excel sheets.
+
+    Default is to use:
+
+    * `xlsxwriter <https://pypi.org/project/XlsxWriter/>`__ for xlsx files if xlsxwriter
+      is installed otherwise `openpyxl <https://pypi.org/project/openpyxl/>`__
+    * `odswriter <https://pypi.org/project/odswriter/>`__ for ods files
+
+    See ``DataFrame.to_excel`` for typical usage.
+
+    The writer should be used as a context manager. Otherwise, call `close()` to save
+    and close any opened file handles.
+
+    Parameters
+    ----------
+    path : str or typing.BinaryIO
+        Path to xls or xlsx or ods file.
+    engine : str (optional)
+        Engine to use for writing. If None, defaults to
+        ``io.excel.<extension>.writer``.  NOTE: can only be passed as a keyword
+        argument.
+    date_format : str, default None
+        Format string for dates written into Excel files (e.g. 'YYYY-MM-DD').
+    datetime_format : str, default None
+        Format string for datetime objects written into Excel files.
+        (e.g. 'YYYY-MM-DD HH:MM:SS').
+    mode : {{'w', 'a'}}, default 'w'
+        File mode to use (write or append). Append does not work with fsspec URLs.
+    {storage_options}
+
+    if_sheet_exists : {{'error', 'new', 'replace', 'overlay'}}, default 'error'
+        How to behave when trying to write to a sheet that already
+        exists (append mode only).
+
+        * error: raise a ValueError.
+        * new: Create a new sheet, with a name determined by the engine.
+        * replace: Delete the contents of the sheet before writing to it.
+        * overlay: Write contents to the existing sheet without first removing,
+          but possibly over top of, the existing contents.
+
+        .. versionadded:: 1.3.0
+
+        .. versionchanged:: 1.4.0
+
+           Added ``overlay`` option
+
+    engine_kwargs : dict, optional
+        Keyword arguments to be passed into the engine. These will be passed to
+        the following functions of the respective engines:
+
+        * xlsxwriter: ``xlsxwriter.Workbook(file, **engine_kwargs)``
+        * openpyxl (write mode): ``openpyxl.Workbook(**engine_kwargs)``
+        * openpyxl (append mode): ``openpyxl.load_workbook(file, **engine_kwargs)``
+        * odswriter: ``odf.opendocument.OpenDocumentSpreadsheet(**engine_kwargs)``
+
+        .. versionadded:: 1.3.0
+
+    Notes
+    -----
+    For compatibility with CSV writers, ExcelWriter serializes lists
+    and dicts to strings before writing.
+
+    Examples
+    --------
+    Default usage:
+
+    >>> df = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"])  # doctest: +SKIP
+    >>> with pd.ExcelWriter("path_to_file.xlsx") as writer:
+    ...     df.to_excel(writer)  # doctest: +SKIP
+
+    To write to separate sheets in a single file:
+
+    >>> df1 = pd.DataFrame([["AAA", "BBB"]], columns=["Spam", "Egg"])  # doctest: +SKIP
+    >>> df2 = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"])  # doctest: +SKIP
+    >>> with pd.ExcelWriter("path_to_file.xlsx") as writer:
+    ...     df1.to_excel(writer, sheet_name="Sheet1")  # doctest: +SKIP
+    ...     df2.to_excel(writer, sheet_name="Sheet2")  # doctest: +SKIP
+
+    You can set the date format or datetime format:
+
+    >>> from datetime import date, datetime  # doctest: +SKIP
+    >>> df = pd.DataFrame(
+    ...     [
+    ...         [date(2014, 1, 31), date(1999, 9, 24)],
+    ...         [datetime(1998, 5, 26, 23, 33, 4), datetime(2014, 2, 28, 13, 5, 13)],
+    ...     ],
+    ...     index=["Date", "Datetime"],
+    ...     columns=["X", "Y"],
+    ... )  # doctest: +SKIP
+    >>> with pd.ExcelWriter(
+    ...     "path_to_file.xlsx",
+    ...     date_format="YYYY-MM-DD",
+    ...     datetime_format="YYYY-MM-DD HH:MM:SS"
+    ... ) as writer:
+    ...     df.to_excel(writer)  # doctest: +SKIP
+
+    You can also append to an existing Excel file:
+
+    >>> with pd.ExcelWriter("path_to_file.xlsx", mode="a", engine="openpyxl") as writer:
+    ...     df.to_excel(writer, sheet_name="Sheet3")  # doctest: +SKIP
+
+    Here, the `if_sheet_exists` parameter can be set to replace a sheet if it
+    already exists:
+
+    >>> with ExcelWriter(
+    ...     "path_to_file.xlsx",
+    ...     mode="a",
+    ...     engine="openpyxl",
+    ...     if_sheet_exists="replace",
+    ... ) as writer:
+    ...     df.to_excel(writer, sheet_name="Sheet1")  # doctest: +SKIP
+
+    You can also write multiple DataFrames to a single sheet. Note that the
+    ``if_sheet_exists`` parameter needs to be set to ``overlay``:
+
+    >>> with ExcelWriter("path_to_file.xlsx",
+    ...     mode="a",
+    ...     engine="openpyxl",
+    ...     if_sheet_exists="overlay",
+    ... ) as writer:
+    ...     df1.to_excel(writer, sheet_name="Sheet1")
+    ...     df2.to_excel(writer, sheet_name="Sheet1", startcol=3)  # doctest: +SKIP
+
+    You can store Excel file in RAM:
+
+    >>> import io
+    >>> df = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"])
+    >>> buffer = io.BytesIO()
+    >>> with pd.ExcelWriter(buffer) as writer:
+    ...     df.to_excel(writer)
+
+    You can pack Excel file into zip archive:
+
+    >>> import zipfile  # doctest: +SKIP
+    >>> df = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"])  # doctest: +SKIP
+    >>> with zipfile.ZipFile("path_to_file.zip", "w") as zf:
+    ...     with zf.open("filename.xlsx", "w") as buffer:
+    ...         with pd.ExcelWriter(buffer) as writer:
+    ...             df.to_excel(writer)  # doctest: +SKIP
+
+    You can specify additional arguments to the underlying engine:
+
+    >>> with pd.ExcelWriter(
+    ...     "path_to_file.xlsx",
+    ...     engine="xlsxwriter",
+    ...     engine_kwargs={{"options": {{"nan_inf_to_errors": True}}}}
+    ... ) as writer:
+    ...     df.to_excel(writer)  # doctest: +SKIP
+
+    In append mode, ``engine_kwargs`` are passed through to
+    openpyxl's ``load_workbook``:
+
+    >>> with pd.ExcelWriter(
+    ...     "path_to_file.xlsx",
+    ...     engine="openpyxl",
+    ...     mode="a",
+    ...     engine_kwargs={{"keep_vba": True}}
+    ... ) as writer:
+    ...     df.to_excel(writer, sheet_name="Sheet2")  # doctest: +SKIP
+    """
+
+    # Defining an ExcelWriter implementation (see abstract methods for more...)
+
+    # - Mandatory
+    #   - ``write_cells(self, cells, sheet_name=None, startrow=0, startcol=0)``
+    #     --> called to write additional DataFrames to disk
+    #   - ``_supported_extensions`` (tuple of supported extensions), used to
+    #      check that engine supports the given extension.
+    #   - ``_engine`` - string that gives the engine name. Necessary to
+    #     instantiate class directly and bypass ``ExcelWriterMeta`` engine
+    #     lookup.
+    #   - ``save(self)`` --> called to save file to disk
+    # - Mostly mandatory (i.e. should at least exist)
+    #   - book, cur_sheet, path
+
+    # - Optional:
+    #   - ``__init__(self, path, engine=None, **kwargs)`` --> always called
+    #     with path as first argument.
+
+    # You also need to register the class with ``register_writer()``.
+    # Technically, ExcelWriter implementations don't need to subclass
+    # ExcelWriter.
+
+    _engine: str
+    _supported_extensions: tuple[str, ...]
+
+    def __new__(
+        cls,
+        path: FilePath | WriteExcelBuffer | ExcelWriter,
+        engine: str | None = None,
+        date_format: str | None = None,
+        datetime_format: str | None = None,
+        mode: str = "w",
+        storage_options: StorageOptions | None = None,
+        if_sheet_exists: ExcelWriterIfSheetExists | None = None,
+        engine_kwargs: dict | None = None,
+    ) -> Self:
+        # only switch class if generic(ExcelWriter)
+        if cls is ExcelWriter:
+            if engine is None or (isinstance(engine, str) and engine == "auto"):
+                if isinstance(path, str):
+                    ext = os.path.splitext(path)[-1][1:]
+                else:
+                    ext = "xlsx"
+
+                try:
+                    engine = config.get_option(f"io.excel.{ext}.writer", silent=True)
+                    if engine == "auto":
+                        engine = get_default_engine(ext, mode="writer")
+                except KeyError as err:
+                    raise ValueError(f"No engine for filetype: '{ext}'") from err
+
+            # for mypy
+            assert engine is not None
+            #  error: Incompatible types in assignment (expression has type
+            #  "type[ExcelWriter[Any]]", variable has type "type[Self]")
+            cls = get_writer(engine)  # type: ignore[assignment]
+
+        return object.__new__(cls)
+
+    # declare external properties you can count on
+    _path = None
+
+    @property
+    def supported_extensions(self) -> tuple[str, ...]:
+        """Extensions that writer engine supports."""
+        return self._supported_extensions
+
+    @property
+    def engine(self) -> str:
+        """Name of engine."""
+        return self._engine
+
+    @property
+    def sheets(self) -> dict[str, Any]:
+        """Mapping of sheet names to sheet objects."""
+        raise NotImplementedError
+
+    @property
+    def book(self) -> _WorkbookT:
+        """
+        Book instance. Class type will depend on the engine used.
+
+        This attribute can be used to access engine-specific features.
+        """
+        raise NotImplementedError
+
+    def _write_cells(
+        self,
+        cells,
+        sheet_name: str | None = None,
+        startrow: int = 0,
+        startcol: int = 0,
+        freeze_panes: tuple[int, int] | None = None,
+    ) -> None:
+        """
+        Write given formatted cells into Excel an excel sheet
+
+        Parameters
+        ----------
+        cells : generator
+            cell of formatted data to save to Excel sheet
+        sheet_name : str, default None
+            Name of Excel sheet, if None, then use self.cur_sheet
+        startrow : upper left cell row to dump data frame
+        startcol : upper left cell column to dump data frame
+        freeze_panes: int tuple of length 2
+            contains the bottom-most row and right-most column to freeze
+        """
+        raise NotImplementedError
+
+    def _save(self) -> None:
+        """
+        Save workbook to disk.
+        """
+        raise NotImplementedError
+
+    def __init__(
+        self,
+        path: FilePath | WriteExcelBuffer | ExcelWriter,
+        engine: str | None = None,
+        date_format: str | None = None,
+        datetime_format: str | None = None,
+        mode: str = "w",
+        storage_options: StorageOptions | None = None,
+        if_sheet_exists: ExcelWriterIfSheetExists | None = None,
+        engine_kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        # validate that this engine can handle the extension
+        if isinstance(path, str):
+            ext = os.path.splitext(path)[-1]
+            self.check_extension(ext)
+
+        # use mode to open the file
+        if "b" not in mode:
+            mode += "b"
+        # use "a" for the user to append data to excel but internally use "r+" to let
+        # the excel backend first read the existing file and then write any data to it
+        mode = mode.replace("a", "r+")
+
+        if if_sheet_exists not in (None, "error", "new", "replace", "overlay"):
+            raise ValueError(
+                f"'{if_sheet_exists}' is not valid for if_sheet_exists. "
+                "Valid options are 'error', 'new', 'replace' and 'overlay'."
+            )
+        if if_sheet_exists and "r+" not in mode:
+            raise ValueError("if_sheet_exists is only valid in append mode (mode='a')")
+        if if_sheet_exists is None:
+            if_sheet_exists = "error"
+        self._if_sheet_exists = if_sheet_exists
+
+        # cast ExcelWriter to avoid adding 'if self._handles is not None'
+        self._handles = IOHandles(
+            cast(IO[bytes], path), compression={"compression": None}
+        )
+        if not isinstance(path, ExcelWriter):
+            self._handles = get_handle(
+                path, mode, storage_options=storage_options, is_text=False
+            )
+        self._cur_sheet = None
+
+        if date_format is None:
+            self._date_format = "YYYY-MM-DD"
+        else:
+            self._date_format = date_format
+        if datetime_format is None:
+            self._datetime_format = "YYYY-MM-DD HH:MM:SS"
+        else:
+            self._datetime_format = datetime_format
+
+        self._mode = mode
+
+    @property
+    def date_format(self) -> str:
+        """
+        Format string for dates written into Excel files (e.g. 'YYYY-MM-DD').
+        """
+        return self._date_format
+
+    @property
+    def datetime_format(self) -> str:
+        """
+        Format string for dates written into Excel files (e.g. 'YYYY-MM-DD').
+        """
+        return self._datetime_format
+
+    @property
+    def if_sheet_exists(self) -> str:
+        """
+        How to behave when writing to a sheet that already exists in append mode.
+        """
+        return self._if_sheet_exists
+
+    def __fspath__(self) -> str:
+        return getattr(self._handles.handle, "name", "")
+
+    def _get_sheet_name(self, sheet_name: str | None) -> str:
+        if sheet_name is None:
+            sheet_name = self._cur_sheet
+        if sheet_name is None:  # pragma: no cover
+            raise ValueError("Must pass explicit sheet_name or set _cur_sheet property")
+        return sheet_name
+
+    def _value_with_fmt(
+        self, val
+    ) -> tuple[
+        int | float | bool | str | datetime.datetime | datetime.date, str | None
+    ]:
+        """
+        Convert numpy types to Python types for the Excel writers.
+
+        Parameters
+        ----------
+        val : object
+            Value to be written into cells
+
+        Returns
+        -------
+        Tuple with the first element being the converted value and the second
+            being an optional format
+        """
+        fmt = None
+
+        if is_integer(val):
+            val = int(val)
+        elif is_float(val):
+            val = float(val)
+        elif is_bool(val):
+            val = bool(val)
+        elif isinstance(val, datetime.datetime):
+            fmt = self._datetime_format
+        elif isinstance(val, datetime.date):
+            fmt = self._date_format
+        elif isinstance(val, datetime.timedelta):
+            val = val.total_seconds() / 86400
+            fmt = "0"
+        else:
+            val = str(val)
+
+        return val, fmt
+
+    @classmethod
+    def check_extension(cls, ext: str) -> Literal[True]:
+        """
+        checks that path's extension against the Writer's supported
+        extensions.  If it isn't supported, raises UnsupportedFiletypeError.
+        """
+        if ext.startswith("."):
+            ext = ext[1:]
+        if not any(ext in extension for extension in cls._supported_extensions):
+            raise ValueError(f"Invalid extension for engine '{cls.engine}': '{ext}'")
+        return True
+
+    # Allow use as a contextmanager
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def close(self) -> None:
+        """synonym for save, to make it more file-like"""
+        self._save()
+        self._handles.close()
+
+
+XLS_SIGNATURES = (
+    b"\x09\x00\x04\x00\x07\x00\x10\x00",  # BIFF2
+    b"\x09\x02\x06\x00\x00\x00\x10\x00",  # BIFF3
+    b"\x09\x04\x06\x00\x00\x00\x10\x00",  # BIFF4
+    b"\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1",  # Compound File Binary
+)
+ZIP_SIGNATURE = b"PK\x03\x04"
+PEEK_SIZE = max(map(len, XLS_SIGNATURES + (ZIP_SIGNATURE,)))
+
+
+@doc(storage_options=_shared_docs["storage_options"])
+def inspect_excel_format(
+    content_or_path: FilePath | ReadBuffer[bytes],
+    storage_options: StorageOptions | None = None,
+) -> str | None:
+    """
+    Inspect the path or content of an excel file and get its format.
+
+    Adopted from xlrd: https://github.com/python-excel/xlrd.
+
+    Parameters
+    ----------
+    content_or_path : str or file-like object
+        Path to file or content of file to inspect. May be a URL.
+    {storage_options}
+
+    Returns
+    -------
+    str or None
+        Format of file if it can be determined.
+
+    Raises
+    ------
+    ValueError
+        If resulting stream is empty.
+    BadZipFile
+        If resulting stream does not have an XLS signature and is not a valid zipfile.
+    """
+    if isinstance(content_or_path, bytes):
+        content_or_path = BytesIO(content_or_path)
+
+    with get_handle(
+        content_or_path, "rb", storage_options=storage_options, is_text=False
+    ) as handle:
+        stream = handle.handle
+        stream.seek(0)
+        buf = stream.read(PEEK_SIZE)
+        if buf is None:
+            raise ValueError("stream is empty")
+        assert isinstance(buf, bytes)
+        peek = buf
+        stream.seek(0)
+
+        if any(peek.startswith(sig) for sig in XLS_SIGNATURES):
+            return "xls"
+        elif not peek.startswith(ZIP_SIGNATURE):
+            return None
+
+        with zipfile.ZipFile(stream) as zf:
+            # Workaround for some third party files that use forward slashes and
+            # lower case names.
+            component_names = [
+                name.replace("\\", "/").lower() for name in zf.namelist()
+            ]
+
+        if "xl/workbook.xml" in component_names:
+            return "xlsx"
+        if "xl/workbook.bin" in component_names:
+            return "xlsb"
+        if "content.xml" in component_names:
+            return "ods"
+        return "zip"
+
+
+class ExcelFile:
+    """
+    Class for parsing tabular Excel sheets into DataFrame objects.
+
+    See read_excel for more documentation.
+
+    Parameters
+    ----------
+    path_or_buffer : str, bytes, path object (pathlib.Path or py._path.local.LocalPath),
+        A file-like object, xlrd workbook or openpyxl workbook.
+        If a string or path object, expected to be a path to a
+        .xls, .xlsx, .xlsb, .xlsm, .odf, .ods, or .odt file.
+    engine : str, default None
+        If io is not a buffer or path, this must be set to identify io.
+        Supported engines: ``xlrd``, ``openpyxl``, ``odf``, ``pyxlsb``, ``calamine``
+        Engine compatibility :
+
+        - ``xlrd`` supports old-style Excel files (.xls).
+        - ``openpyxl`` supports newer Excel file formats.
+        - ``odf`` supports OpenDocument file formats (.odf, .ods, .odt).
+        - ``pyxlsb`` supports Binary Excel files.
+        - ``calamine`` supports Excel (.xls, .xlsx, .xlsm, .xlsb)
+          and OpenDocument (.ods) file formats.
+
+        .. versionchanged:: 1.2.0
+
+           The engine `xlrd <https://xlrd.readthedocs.io/en/latest/>`_
+           now only supports old-style ``.xls`` files.
+           When ``engine=None``, the following logic will be
+           used to determine the engine:
+
+           - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),
+             then `odf <https://pypi.org/project/odfpy/>`_ will be used.
+           - Otherwise if ``path_or_buffer`` is an xls format,
+             ``xlrd`` will be used.
+           - Otherwise if ``path_or_buffer`` is in xlsb format,
+             `pyxlsb <https://pypi.org/project/pyxlsb/>`_ will be used.
+
+           .. versionadded:: 1.3.0
+
+           - Otherwise if `openpyxl <https://pypi.org/project/openpyxl/>`_ is installed,
+             then ``openpyxl`` will be used.
+           - Otherwise if ``xlrd >= 2.0`` is installed, a ``ValueError`` will be raised.
+
+           .. warning::
+
+            Please do not report issues when using ``xlrd`` to read ``.xlsx`` files.
+            This is not supported, switch to using ``openpyxl`` instead.
+    engine_kwargs : dict, optional
+        Arbitrary keyword arguments passed to excel engine.
+
+    Examples
+    --------
+    >>> file = pd.ExcelFile('myfile.xlsx')  # doctest: +SKIP
+    >>> with pd.ExcelFile("myfile.xls") as xls:  # doctest: +SKIP
+    ...     df1 = pd.read_excel(xls, "Sheet1")  # doctest: +SKIP
+    """
+
+    from pandas.io.excel._calamine import CalamineReader
+    from pandas.io.excel._odfreader import ODFReader
+    from pandas.io.excel._openpyxl import OpenpyxlReader
+    from pandas.io.excel._pyxlsb import PyxlsbReader
+    from pandas.io.excel._xlrd import XlrdReader
+
+    _engines: Mapping[str, Any] = {
+        "xlrd": XlrdReader,
+        "openpyxl": OpenpyxlReader,
+        "odf": ODFReader,
+        "pyxlsb": PyxlsbReader,
+        "calamine": CalamineReader,
+    }
+
+    def __init__(
+        self,
+        path_or_buffer,
+        engine: str | None = None,
+        storage_options: StorageOptions | None = None,
+        engine_kwargs: dict | None = None,
+    ) -> None:
+        if engine_kwargs is None:
+            engine_kwargs = {}
+
+        if engine is not None and engine not in self._engines:
+            raise ValueError(f"Unknown engine: {engine}")
+
+        # First argument can also be bytes, so create a buffer
+        if isinstance(path_or_buffer, bytes):
+            path_or_buffer = BytesIO(path_or_buffer)
+            warnings.warn(
+                "Passing bytes to 'read_excel' is deprecated and "
+                "will be removed in a future version. To read from a "
+                "byte string, wrap it in a `BytesIO` object.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
+        # Could be a str, ExcelFile, Book, etc.
+        self.io = path_or_buffer
+        # Always a string
+        self._io = stringify_path(path_or_buffer)
+
+        # Determine xlrd version if installed
+        if import_optional_dependency("xlrd", errors="ignore") is None:
+            xlrd_version = None
+        else:
+            import xlrd
+
+            xlrd_version = Version(get_version(xlrd))
+
+        if engine is None:
+            # Only determine ext if it is needed
+            ext: str | None
+            if xlrd_version is not None and isinstance(path_or_buffer, xlrd.Book):
+                ext = "xls"
+            else:
+                ext = inspect_excel_format(
+                    content_or_path=path_or_buffer, storage_options=storage_options
+                )
+                if ext is None:
+                    raise ValueError(
+                        "Excel file format cannot be determined, you must specify "
+                        "an engine manually."
+                    )
+
+            engine = config.get_option(f"io.excel.{ext}.reader", silent=True)
+            if engine == "auto":
+                engine = get_default_engine(ext, mode="reader")
+
+        assert engine is not None
+        self.engine = engine
+        self.storage_options = storage_options
+
+        self._reader = self._engines[engine](
+            self._io,
+            storage_options=storage_options,
+            engine_kwargs=engine_kwargs,
+        )
+
+    def __fspath__(self):
+        return self._io
+
+    def parse(
+        self,
+        sheet_name: str | int | list[int] | list[str] | None = 0,
+        header: int | Sequence[int] | None = 0,
+        names: SequenceNotStr[Hashable] | range | None = None,
+        index_col: int | Sequence[int] | None = None,
+        usecols=None,
+        converters=None,
+        true_values: Iterable[Hashable] | None = None,
+        false_values: Iterable[Hashable] | None = None,
+        skiprows: Sequence[int] | int | Callable[[int], object] | None = None,
+        nrows: int | None = None,
+        na_values=None,
+        parse_dates: list | dict | bool = False,
+        date_parser: Callable | lib.NoDefault = lib.no_default,
+        date_format: str | dict[Hashable, str] | None = None,
+        thousands: str | None = None,
+        comment: str | None = None,
+        skipfooter: int = 0,
+        dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
+        **kwds,
+    ) -> DataFrame | dict[str, DataFrame] | dict[int, DataFrame]:
+        """
+        Parse specified sheet(s) into a DataFrame.
+
+        Equivalent to read_excel(ExcelFile, ...)  See the read_excel
+        docstring for more info on accepted parameters.
+
+        Returns
+        -------
+        DataFrame or dict of DataFrames
+            DataFrame from the passed in Excel file.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C'])
+        >>> df.to_excel('myfile.xlsx')  # doctest: +SKIP
+        >>> file = pd.ExcelFile('myfile.xlsx')  # doctest: +SKIP
+        >>> file.parse()  # doctest: +SKIP
+        """
+        return self._reader.parse(
+            sheet_name=sheet_name,
+            header=header,
+            names=names,
+            index_col=index_col,
+            usecols=usecols,
+            converters=converters,
+            true_values=true_values,
+            false_values=false_values,
+            skiprows=skiprows,
+            nrows=nrows,
+            na_values=na_values,
+            parse_dates=parse_dates,
+            date_parser=date_parser,
+            date_format=date_format,
+            thousands=thousands,
+            comment=comment,
+            skipfooter=skipfooter,
+            dtype_backend=dtype_backend,
+            **kwds,
+        )
+
+    @property
+    def book(self):
+        return self._reader.book
+
+    @property
+    def sheet_names(self):
+        return self._reader.sheet_names
+
+    def close(self) -> None:
+        """close io if necessary"""
+        self._reader.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()

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

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+from typing import (
+    TYPE_CHECKING,
+    cast,
+)
+
+import numpy as np
+
+from pandas._typing import (
+    FilePath,
+    ReadBuffer,
+    Scalar,
+    StorageOptions,
+)
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+import pandas as pd
+from pandas.core.shared_docs import _shared_docs
+
+from pandas.io.excel._base import BaseExcelReader
+
+if TYPE_CHECKING:
+    from odf.opendocument import OpenDocument
+
+    from pandas._libs.tslibs.nattype import NaTType
+
+
+@doc(storage_options=_shared_docs["storage_options"])
+class ODFReader(BaseExcelReader["OpenDocument"]):
+    def __init__(
+        self,
+        filepath_or_buffer: FilePath | ReadBuffer[bytes],
+        storage_options: StorageOptions | None = None,
+        engine_kwargs: dict | None = None,
+    ) -> None:
+        """
+        Read tables out of OpenDocument formatted files.
+
+        Parameters
+        ----------
+        filepath_or_buffer : str, path to be parsed or
+            an open readable stream.
+        {storage_options}
+        engine_kwargs : dict, optional
+            Arbitrary keyword arguments passed to excel engine.
+        """
+        import_optional_dependency("odf")
+        super().__init__(
+            filepath_or_buffer,
+            storage_options=storage_options,
+            engine_kwargs=engine_kwargs,
+        )
+
+    @property
+    def _workbook_class(self) -> type[OpenDocument]:
+        from odf.opendocument import OpenDocument
+
+        return OpenDocument
+
+    def load_workbook(
+        self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs
+    ) -> OpenDocument:
+        from odf.opendocument import load
+
+        return load(filepath_or_buffer, **engine_kwargs)
+
+    @property
+    def empty_value(self) -> str:
+        """Property for compat with other readers."""
+        return ""
+
+    @property
+    def sheet_names(self) -> list[str]:
+        """Return a list of sheet names present in the document"""
+        from odf.table import Table
+
+        tables = self.book.getElementsByType(Table)
+        return [t.getAttribute("name") for t in tables]
+
+    def get_sheet_by_index(self, index: int):
+        from odf.table import Table
+
+        self.raise_if_bad_sheet_by_index(index)
+        tables = self.book.getElementsByType(Table)
+        return tables[index]
+
+    def get_sheet_by_name(self, name: str):
+        from odf.table import Table
+
+        self.raise_if_bad_sheet_by_name(name)
+        tables = self.book.getElementsByType(Table)
+
+        for table in tables:
+            if table.getAttribute("name") == name:
+                return table
+
+        self.close()
+        raise ValueError(f"sheet {name} not found")
+
+    def get_sheet_data(
+        self, sheet, file_rows_needed: int | None = None
+    ) -> list[list[Scalar | NaTType]]:
+        """
+        Parse an ODF Table into a list of lists
+        """
+        from odf.table import (
+            CoveredTableCell,
+            TableCell,
+            TableRow,
+        )
+
+        covered_cell_name = CoveredTableCell().qname
+        table_cell_name = TableCell().qname
+        cell_names = {covered_cell_name, table_cell_name}
+
+        sheet_rows = sheet.getElementsByType(TableRow)
+        empty_rows = 0
+        max_row_len = 0
+
+        table: list[list[Scalar | NaTType]] = []
+
+        for sheet_row in sheet_rows:
+            sheet_cells = [
+                x
+                for x in sheet_row.childNodes
+                if hasattr(x, "qname") and x.qname in cell_names
+            ]
+            empty_cells = 0
+            table_row: list[Scalar | NaTType] = []
+
+            for sheet_cell in sheet_cells:
+                if sheet_cell.qname == table_cell_name:
+                    value = self._get_cell_value(sheet_cell)
+                else:
+                    value = self.empty_value
+
+                column_repeat = self._get_column_repeat(sheet_cell)
+
+                # Queue up empty values, writing only if content succeeds them
+                if value == self.empty_value:
+                    empty_cells += column_repeat
+                else:
+                    table_row.extend([self.empty_value] * empty_cells)
+                    empty_cells = 0
+                    table_row.extend([value] * column_repeat)
+
+            if max_row_len < len(table_row):
+                max_row_len = len(table_row)
+
+            row_repeat = self._get_row_repeat(sheet_row)
+            if len(table_row) == 0:
+                empty_rows += row_repeat
+            else:
+                # add blank rows to our table
+                table.extend([[self.empty_value]] * empty_rows)
+                empty_rows = 0
+                table.extend(table_row for _ in range(row_repeat))
+            if file_rows_needed is not None and len(table) >= file_rows_needed:
+                break
+
+        # Make our table square
+        for row in table:
+            if len(row) < max_row_len:
+                row.extend([self.empty_value] * (max_row_len - len(row)))
+
+        return table
+
+    def _get_row_repeat(self, row) -> int:
+        """
+        Return number of times this row was repeated
+        Repeating an empty row appeared to be a common way
+        of representing sparse rows in the table.
+        """
+        from odf.namespaces import TABLENS
+
+        return int(row.attributes.get((TABLENS, "number-rows-repeated"), 1))
+
+    def _get_column_repeat(self, cell) -> int:
+        from odf.namespaces import TABLENS
+
+        return int(cell.attributes.get((TABLENS, "number-columns-repeated"), 1))
+
+    def _get_cell_value(self, cell) -> Scalar | NaTType:
+        from odf.namespaces import OFFICENS
+
+        if str(cell) == "#N/A":
+            return np.nan
+
+        cell_type = cell.attributes.get((OFFICENS, "value-type"))
+        if cell_type == "boolean":
+            if str(cell) == "TRUE":
+                return True
+            return False
+        if cell_type is None:
+            return self.empty_value
+        elif cell_type == "float":
+            # GH5394
+            cell_value = float(cell.attributes.get((OFFICENS, "value")))
+            val = int(cell_value)
+            if val == cell_value:
+                return val
+            return cell_value
+        elif cell_type == "percentage":
+            cell_value = cell.attributes.get((OFFICENS, "value"))
+            return float(cell_value)
+        elif cell_type == "string":
+            return self._get_cell_string_value(cell)
+        elif cell_type == "currency":
+            cell_value = cell.attributes.get((OFFICENS, "value"))
+            return float(cell_value)
+        elif cell_type == "date":
+            cell_value = cell.attributes.get((OFFICENS, "date-value"))
+            return pd.Timestamp(cell_value)
+        elif cell_type == "time":
+            stamp = pd.Timestamp(str(cell))
+            # cast needed here because Scalar doesn't include datetime.time
+            return cast(Scalar, stamp.time())
+        else:
+            self.close()
+            raise ValueError(f"Unrecognized type {cell_type}")
+
+    def _get_cell_string_value(self, cell) -> str:
+        """
+        Find and decode OpenDocument text:s tags that represent
+        a run length encoded sequence of space characters.
+        """
+        from odf.element import Element
+        from odf.namespaces import TEXTNS
+        from odf.office import Annotation
+        from odf.text import S
+
+        office_annotation = Annotation().qname
+        text_s = S().qname
+
+        value = []
+
+        for fragment in cell.childNodes:
+            if isinstance(fragment, Element):
+                if fragment.qname == text_s:
+                    spaces = int(fragment.attributes.get((TEXTNS, "c"), 1))
+                    value.append(" " * spaces)
+                elif fragment.qname == office_annotation:
+                    continue
+                else:
+                    # recursive impl needed in case of nested fragments
+                    # with multiple spaces
+                    # https://github.com/pandas-dev/pandas/pull/36175#discussion_r484639704
+                    value.append(self._get_cell_string_value(fragment))
+            else:
+                value.append(str(fragment).strip("\n"))
+        return "".join(value)

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

@@ -0,0 +1,127 @@
+# pyright: reportMissingImports=false
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+from pandas.core.shared_docs import _shared_docs
+
+from pandas.io.excel._base import BaseExcelReader
+
+if TYPE_CHECKING:
+    from pyxlsb import Workbook
+
+    from pandas._typing import (
+        FilePath,
+        ReadBuffer,
+        Scalar,
+        StorageOptions,
+    )
+
+
+class PyxlsbReader(BaseExcelReader["Workbook"]):
+    @doc(storage_options=_shared_docs["storage_options"])
+    def __init__(
+        self,
+        filepath_or_buffer: FilePath | ReadBuffer[bytes],
+        storage_options: StorageOptions | None = None,
+        engine_kwargs: dict | None = None,
+    ) -> None:
+        """
+        Reader using pyxlsb engine.
+
+        Parameters
+        ----------
+        filepath_or_buffer : str, path object, or Workbook
+            Object to be parsed.
+        {storage_options}
+        engine_kwargs : dict, optional
+            Arbitrary keyword arguments passed to excel engine.
+        """
+        import_optional_dependency("pyxlsb")
+        # This will call load_workbook on the filepath or buffer
+        # And set the result to the book-attribute
+        super().__init__(
+            filepath_or_buffer,
+            storage_options=storage_options,
+            engine_kwargs=engine_kwargs,
+        )
+
+    @property
+    def _workbook_class(self) -> type[Workbook]:
+        from pyxlsb import Workbook
+
+        return Workbook
+
+    def load_workbook(
+        self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs
+    ) -> Workbook:
+        from pyxlsb import open_workbook
+
+        # TODO: hack in buffer capability
+        # This might need some modifications to the Pyxlsb library
+        # Actual work for opening it is in xlsbpackage.py, line 20-ish
+
+        return open_workbook(filepath_or_buffer, **engine_kwargs)
+
+    @property
+    def sheet_names(self) -> list[str]:
+        return self.book.sheets
+
+    def get_sheet_by_name(self, name: str):
+        self.raise_if_bad_sheet_by_name(name)
+        return self.book.get_sheet(name)
+
+    def get_sheet_by_index(self, index: int):
+        self.raise_if_bad_sheet_by_index(index)
+        # pyxlsb sheets are indexed from 1 onwards
+        # There's a fix for this in the source, but the pypi package doesn't have it
+        return self.book.get_sheet(index + 1)
+
+    def _convert_cell(self, cell) -> Scalar:
+        # TODO: there is no way to distinguish between floats and datetimes in pyxlsb
+        # This means that there is no way to read datetime types from an xlsb file yet
+        if cell.v is None:
+            return ""  # Prevents non-named columns from not showing up as Unnamed: i
+        if isinstance(cell.v, float):
+            val = int(cell.v)
+            if val == cell.v:
+                return val
+            else:
+                return float(cell.v)
+
+        return cell.v
+
+    def get_sheet_data(
+        self,
+        sheet,
+        file_rows_needed: int | None = None,
+    ) -> list[list[Scalar]]:
+        data: list[list[Scalar]] = []
+        previous_row_number = -1
+        # When sparse=True the rows can have different lengths and empty rows are
+        # not returned. The cells are namedtuples of row, col, value (r, c, v).
+        for row in sheet.rows(sparse=True):
+            row_number = row[0].r
+            converted_row = [self._convert_cell(cell) for cell in row]
+            while converted_row and converted_row[-1] == "":
+                # trim trailing empty elements
+                converted_row.pop()
+            if converted_row:
+                data.extend([[]] * (row_number - previous_row_number - 1))
+                data.append(converted_row)
+                previous_row_number = row_number
+            if file_rows_needed is not None and len(data) >= file_rows_needed:
+                break
+        if data:
+            # extend rows to max_width
+            max_width = max(len(data_row) for data_row in data)
+            if min(len(data_row) for data_row in data) < max_width:
+                empty_cell: list[Scalar] = [""]
+                data = [
+                    data_row + (max_width - len(data_row)) * empty_cell
+                    for data_row in data
+                ]
+        return data

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

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+from collections.abc import (
+    Hashable,
+    Iterable,
+    MutableMapping,
+    Sequence,
+)
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Literal,
+    TypeVar,
+    overload,
+)
+
+from pandas.compat._optional import import_optional_dependency
+
+from pandas.core.dtypes.common import (
+    is_integer,
+    is_list_like,
+)
+
+if TYPE_CHECKING:
+    from pandas.io.excel._base import ExcelWriter
+
+    ExcelWriter_t = type[ExcelWriter]
+    usecols_func = TypeVar("usecols_func", bound=Callable[[Hashable], object])
+
+_writers: MutableMapping[str, ExcelWriter_t] = {}
+
+
+def register_writer(klass: ExcelWriter_t) -> None:
+    """
+    Add engine to the excel writer registry.io.excel.
+
+    You must use this method to integrate with ``to_excel``.
+
+    Parameters
+    ----------
+    klass : ExcelWriter
+    """
+    if not callable(klass):
+        raise ValueError("Can only register callables as engines")
+    engine_name = klass._engine
+    _writers[engine_name] = klass
+
+
+def get_default_engine(ext: str, mode: Literal["reader", "writer"] = "reader") -> str:
+    """
+    Return the default reader/writer for the given extension.
+
+    Parameters
+    ----------
+    ext : str
+        The excel file extension for which to get the default engine.
+    mode : str {'reader', 'writer'}
+        Whether to get the default engine for reading or writing.
+        Either 'reader' or 'writer'
+
+    Returns
+    -------
+    str
+        The default engine for the extension.
+    """
+    _default_readers = {
+        "xlsx": "openpyxl",
+        "xlsm": "openpyxl",
+        "xlsb": "pyxlsb",
+        "xls": "xlrd",
+        "ods": "odf",
+    }
+    _default_writers = {
+        "xlsx": "openpyxl",
+        "xlsm": "openpyxl",
+        "xlsb": "pyxlsb",
+        "ods": "odf",
+    }
+    assert mode in ["reader", "writer"]
+    if mode == "writer":
+        # Prefer xlsxwriter over openpyxl if installed
+        xlsxwriter = import_optional_dependency("xlsxwriter", errors="warn")
+        if xlsxwriter:
+            _default_writers["xlsx"] = "xlsxwriter"
+        return _default_writers[ext]
+    else:
+        return _default_readers[ext]
+
+
+def get_writer(engine_name: str) -> ExcelWriter_t:
+    try:
+        return _writers[engine_name]
+    except KeyError as err:
+        raise ValueError(f"No Excel writer '{engine_name}'") from err
+
+
+def _excel2num(x: str) -> int:
+    """
+    Convert Excel column name like 'AB' to 0-based column index.
+
+    Parameters
+    ----------
+    x : str
+        The Excel column name to convert to a 0-based column index.
+
+    Returns
+    -------
+    num : int
+        The column index corresponding to the name.
+
+    Raises
+    ------
+    ValueError
+        Part of the Excel column name was invalid.
+    """
+    index = 0
+
+    for c in x.upper().strip():
+        cp = ord(c)
+
+        if cp < ord("A") or cp > ord("Z"):
+            raise ValueError(f"Invalid column name: {x}")
+
+        index = index * 26 + cp - ord("A") + 1
+
+    return index - 1
+
+
+def _range2cols(areas: str) -> list[int]:
+    """
+    Convert comma separated list of column names and ranges to indices.
+
+    Parameters
+    ----------
+    areas : str
+        A string containing a sequence of column ranges (or areas).
+
+    Returns
+    -------
+    cols : list
+        A list of 0-based column indices.
+
+    Examples
+    --------
+    >>> _range2cols('A:E')
+    [0, 1, 2, 3, 4]
+    >>> _range2cols('A,C,Z:AB')
+    [0, 2, 25, 26, 27]
+    """
+    cols: list[int] = []
+
+    for rng in areas.split(","):
+        if ":" in rng:
+            rngs = rng.split(":")
+            cols.extend(range(_excel2num(rngs[0]), _excel2num(rngs[1]) + 1))
+        else:
+            cols.append(_excel2num(rng))
+
+    return cols
+
+
+@overload
+def maybe_convert_usecols(usecols: str | list[int]) -> list[int]:
+    ...
+
+
+@overload
+def maybe_convert_usecols(usecols: list[str]) -> list[str]:
+    ...
+
+
+@overload
+def maybe_convert_usecols(usecols: usecols_func) -> usecols_func:
+    ...
+
+
+@overload
+def maybe_convert_usecols(usecols: None) -> None:
+    ...
+
+
+def maybe_convert_usecols(
+    usecols: str | list[int] | list[str] | usecols_func | None,
+) -> None | list[int] | list[str] | usecols_func:
+    """
+    Convert `usecols` into a compatible format for parsing in `parsers.py`.
+
+    Parameters
+    ----------
+    usecols : object
+        The use-columns object to potentially convert.
+
+    Returns
+    -------
+    converted : object
+        The compatible format of `usecols`.
+    """
+    if usecols is None:
+        return usecols
+
+    if is_integer(usecols):
+        raise ValueError(
+            "Passing an integer for `usecols` is no longer supported.  "
+            "Please pass in a list of int from 0 to `usecols` inclusive instead."
+        )
+
+    if isinstance(usecols, str):
+        return _range2cols(usecols)
+
+    return usecols
+
+
+@overload
+def validate_freeze_panes(freeze_panes: tuple[int, int]) -> Literal[True]:
+    ...
+
+
+@overload
+def validate_freeze_panes(freeze_panes: None) -> Literal[False]:
+    ...
+
+
+def validate_freeze_panes(freeze_panes: tuple[int, int] | None) -> bool:
+    if freeze_panes is not None:
+        if len(freeze_panes) == 2 and all(
+            isinstance(item, int) for item in freeze_panes
+        ):
+            return True
+
+        raise ValueError(
+            "freeze_panes must be of form (row, column) "
+            "where row and column are integers"
+        )
+
+    # freeze_panes wasn't specified, return False so it won't be applied
+    # to output sheet
+    return False
+
+
+def fill_mi_header(
+    row: list[Hashable], control_row: list[bool]
+) -> tuple[list[Hashable], list[bool]]:
+    """
+    Forward fill blank entries in row but only inside the same parent index.
+
+    Used for creating headers in Multiindex.
+
+    Parameters
+    ----------
+    row : list
+        List of items in a single row.
+    control_row : list of bool
+        Helps to determine if particular column is in same parent index as the
+        previous value. Used to stop propagation of empty cells between
+        different indexes.
+
+    Returns
+    -------
+    Returns changed row and control_row
+    """
+    last = row[0]
+    for i in range(1, len(row)):
+        if not control_row[i]:
+            last = row[i]
+
+        if row[i] == "" or row[i] is None:
+            row[i] = last
+        else:
+            control_row[i] = False
+            last = row[i]
+
+    return row, control_row
+
+
+def pop_header_name(
+    row: list[Hashable], index_col: int | Sequence[int]
+) -> tuple[Hashable | None, list[Hashable]]:
+    """
+    Pop the header name for MultiIndex parsing.
+
+    Parameters
+    ----------
+    row : list
+        The data row to parse for the header name.
+    index_col : int, list
+        The index columns for our data. Assumed to be non-null.
+
+    Returns
+    -------
+    header_name : str
+        The extracted header name.
+    trimmed_row : list
+        The original data row with the header name removed.
+    """
+    # Pop out header name and fill w/blank.
+    if is_list_like(index_col):
+        assert isinstance(index_col, Iterable)
+        i = max(index_col)
+    else:
+        assert not isinstance(index_col, Iterable)
+        i = index_col
+
+    header_name = row[i]
+    header_name = None if header_name == "" else header_name
+
+    return header_name, row[:i] + [""] + row[i + 1 :]
+
+
+def combine_kwargs(engine_kwargs: dict[str, Any] | None, kwargs: dict) -> dict:
+    """
+    Used to combine two sources of kwargs for the backend engine.
+
+    Use of kwargs is deprecated, this function is solely for use in 1.3 and should
+    be removed in 1.4/2.0. Also _base.ExcelWriter.__new__ ensures either engine_kwargs
+    or kwargs must be None or empty respectively.
+
+    Parameters
+    ----------
+    engine_kwargs: dict
+        kwargs to be passed through to the engine.
+    kwargs: dict
+        kwargs to be psased through to the engine (deprecated)
+
+    Returns
+    -------
+    engine_kwargs combined with kwargs
+    """
+    if engine_kwargs is None:
+        result = {}
+    else:
+        result = engine_kwargs.copy()
+    result.update(kwargs)
+    return result

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

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from datetime import time
+import math
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+from pandas.core.shared_docs import _shared_docs
+
+from pandas.io.excel._base import BaseExcelReader
+
+if TYPE_CHECKING:
+    from xlrd import Book
+
+    from pandas._typing import (
+        Scalar,
+        StorageOptions,
+    )
+
+
+class XlrdReader(BaseExcelReader["Book"]):
+    @doc(storage_options=_shared_docs["storage_options"])
+    def __init__(
+        self,
+        filepath_or_buffer,
+        storage_options: StorageOptions | None = None,
+        engine_kwargs: dict | None = None,
+    ) -> None:
+        """
+        Reader using xlrd engine.
+
+        Parameters
+        ----------
+        filepath_or_buffer : str, path object or Workbook
+            Object to be parsed.
+        {storage_options}
+        engine_kwargs : dict, optional
+            Arbitrary keyword arguments passed to excel engine.
+        """
+        err_msg = "Install xlrd >= 2.0.1 for xls Excel support"
+        import_optional_dependency("xlrd", extra=err_msg)
+        super().__init__(
+            filepath_or_buffer,
+            storage_options=storage_options,
+            engine_kwargs=engine_kwargs,
+        )
+
+    @property
+    def _workbook_class(self) -> type[Book]:
+        from xlrd import Book
+
+        return Book
+
+    def load_workbook(self, filepath_or_buffer, engine_kwargs) -> Book:
+        from xlrd import open_workbook
+
+        if hasattr(filepath_or_buffer, "read"):
+            data = filepath_or_buffer.read()
+            return open_workbook(file_contents=data, **engine_kwargs)
+        else:
+            return open_workbook(filepath_or_buffer, **engine_kwargs)
+
+    @property
+    def sheet_names(self):
+        return self.book.sheet_names()
+
+    def get_sheet_by_name(self, name):
+        self.raise_if_bad_sheet_by_name(name)
+        return self.book.sheet_by_name(name)
+
+    def get_sheet_by_index(self, index):
+        self.raise_if_bad_sheet_by_index(index)
+        return self.book.sheet_by_index(index)
+
+    def get_sheet_data(
+        self, sheet, file_rows_needed: int | None = None
+    ) -> list[list[Scalar]]:
+        from xlrd import (
+            XL_CELL_BOOLEAN,
+            XL_CELL_DATE,
+            XL_CELL_ERROR,
+            XL_CELL_NUMBER,
+            xldate,
+        )
+
+        epoch1904 = self.book.datemode
+
+        def _parse_cell(cell_contents, cell_typ):
+            """
+            converts the contents of the cell into a pandas appropriate object
+            """
+            if cell_typ == XL_CELL_DATE:
+                # Use the newer xlrd datetime handling.
+                try:
+                    cell_contents = xldate.xldate_as_datetime(cell_contents, epoch1904)
+                except OverflowError:
+                    return cell_contents
+
+                # Excel doesn't distinguish between dates and time,
+                # so we treat dates on the epoch as times only.
+                # Also, Excel supports 1900 and 1904 epochs.
+                year = (cell_contents.timetuple())[0:3]
+                if (not epoch1904 and year == (1899, 12, 31)) or (
+                    epoch1904 and year == (1904, 1, 1)
+                ):
+                    cell_contents = time(
+                        cell_contents.hour,
+                        cell_contents.minute,
+                        cell_contents.second,
+                        cell_contents.microsecond,
+                    )
+
+            elif cell_typ == XL_CELL_ERROR:
+                cell_contents = np.nan
+            elif cell_typ == XL_CELL_BOOLEAN:
+                cell_contents = bool(cell_contents)
+            elif cell_typ == XL_CELL_NUMBER:
+                # GH5394 - Excel 'numbers' are always floats
+                # it's a minimal perf hit and less surprising
+                if math.isfinite(cell_contents):
+                    # GH54564 - don't attempt to convert NaN/Inf
+                    val = int(cell_contents)
+                    if val == cell_contents:
+                        cell_contents = val
+            return cell_contents
+
+        data = []
+
+        nrows = sheet.nrows
+        if file_rows_needed is not None:
+            nrows = min(nrows, file_rows_needed)
+        for i in range(nrows):
+            row = [
+                _parse_cell(value, typ)
+                for value, typ in zip(sheet.row_values(i), sheet.row_types(i))
+            ]
+            data.append(row)
+
+        return data

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

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import json
+from typing import (
+    TYPE_CHECKING,
+    Any,
+)
+
+from pandas.io.excel._base import ExcelWriter
+from pandas.io.excel._util import (
+    combine_kwargs,
+    validate_freeze_panes,
+)
+
+if TYPE_CHECKING:
+    from pandas._typing import (
+        ExcelWriterIfSheetExists,
+        FilePath,
+        StorageOptions,
+        WriteExcelBuffer,
+    )
+
+
+class _XlsxStyler:
+    # Map from openpyxl-oriented styles to flatter xlsxwriter representation
+    # Ordering necessary for both determinism and because some are keyed by
+    # prefixes of others.
+    STYLE_MAPPING: dict[str, list[tuple[tuple[str, ...], str]]] = {
+        "font": [
+            (("name",), "font_name"),
+            (("sz",), "font_size"),
+            (("size",), "font_size"),
+            (("color", "rgb"), "font_color"),
+            (("color",), "font_color"),
+            (("b",), "bold"),
+            (("bold",), "bold"),
+            (("i",), "italic"),
+            (("italic",), "italic"),
+            (("u",), "underline"),
+            (("underline",), "underline"),
+            (("strike",), "font_strikeout"),
+            (("vertAlign",), "font_script"),
+            (("vertalign",), "font_script"),
+        ],
+        "number_format": [(("format_code",), "num_format"), ((), "num_format")],
+        "protection": [(("locked",), "locked"), (("hidden",), "hidden")],
+        "alignment": [
+            (("horizontal",), "align"),
+            (("vertical",), "valign"),
+            (("text_rotation",), "rotation"),
+            (("wrap_text",), "text_wrap"),
+            (("indent",), "indent"),
+            (("shrink_to_fit",), "shrink"),
+        ],
+        "fill": [
+            (("patternType",), "pattern"),
+            (("patterntype",), "pattern"),
+            (("fill_type",), "pattern"),
+            (("start_color", "rgb"), "fg_color"),
+            (("fgColor", "rgb"), "fg_color"),
+            (("fgcolor", "rgb"), "fg_color"),
+            (("start_color",), "fg_color"),
+            (("fgColor",), "fg_color"),
+            (("fgcolor",), "fg_color"),
+            (("end_color", "rgb"), "bg_color"),
+            (("bgColor", "rgb"), "bg_color"),
+            (("bgcolor", "rgb"), "bg_color"),
+            (("end_color",), "bg_color"),
+            (("bgColor",), "bg_color"),
+            (("bgcolor",), "bg_color"),
+        ],
+        "border": [
+            (("color", "rgb"), "border_color"),
+            (("color",), "border_color"),
+            (("style",), "border"),
+            (("top", "color", "rgb"), "top_color"),
+            (("top", "color"), "top_color"),
+            (("top", "style"), "top"),
+            (("top",), "top"),
+            (("right", "color", "rgb"), "right_color"),
+            (("right", "color"), "right_color"),
+            (("right", "style"), "right"),
+            (("right",), "right"),
+            (("bottom", "color", "rgb"), "bottom_color"),
+            (("bottom", "color"), "bottom_color"),
+            (("bottom", "style"), "bottom"),
+            (("bottom",), "bottom"),
+            (("left", "color", "rgb"), "left_color"),
+            (("left", "color"), "left_color"),
+            (("left", "style"), "left"),
+            (("left",), "left"),
+        ],
+    }
+
+    @classmethod
+    def convert(cls, style_dict, num_format_str=None):
+        """
+        converts a style_dict to an xlsxwriter format dict
+
+        Parameters
+        ----------
+        style_dict : style dictionary to convert
+        num_format_str : optional number format string
+        """
+        # Create a XlsxWriter format object.
+        props = {}
+
+        if num_format_str is not None:
+            props["num_format"] = num_format_str
+
+        if style_dict is None:
+            return props
+
+        if "borders" in style_dict:
+            style_dict = style_dict.copy()
+            style_dict["border"] = style_dict.pop("borders")
+
+        for style_group_key, style_group in style_dict.items():
+            for src, dst in cls.STYLE_MAPPING.get(style_group_key, []):
+                # src is a sequence of keys into a nested dict
+                # dst is a flat key
+                if dst in props:
+                    continue
+                v = style_group
+                for k in src:
+                    try:
+                        v = v[k]
+                    except (KeyError, TypeError):
+                        break
+                else:
+                    props[dst] = v
+
+        if isinstance(props.get("pattern"), str):
+            # TODO: support other fill patterns
+            props["pattern"] = 0 if props["pattern"] == "none" else 1
+
+        for k in ["border", "top", "right", "bottom", "left"]:
+            if isinstance(props.get(k), str):
+                try:
+                    props[k] = [
+                        "none",
+                        "thin",
+                        "medium",
+                        "dashed",
+                        "dotted",
+                        "thick",
+                        "double",
+                        "hair",
+                        "mediumDashed",
+                        "dashDot",
+                        "mediumDashDot",
+                        "dashDotDot",
+                        "mediumDashDotDot",
+                        "slantDashDot",
+                    ].index(props[k])
+                except ValueError:
+                    props[k] = 2
+
+        if isinstance(props.get("font_script"), str):
+            props["font_script"] = ["baseline", "superscript", "subscript"].index(
+                props["font_script"]
+            )
+
+        if isinstance(props.get("underline"), str):
+            props["underline"] = {
+                "none": 0,
+                "single": 1,
+                "double": 2,
+                "singleAccounting": 33,
+                "doubleAccounting": 34,
+            }[props["underline"]]
+
+        # GH 30107 - xlsxwriter uses different name
+        if props.get("valign") == "center":
+            props["valign"] = "vcenter"
+
+        return props
+
+
+class XlsxWriter(ExcelWriter):
+    _engine = "xlsxwriter"
+    _supported_extensions = (".xlsx",)
+
+    def __init__(
+        self,
+        path: FilePath | WriteExcelBuffer | ExcelWriter,
+        engine: str | None = None,
+        date_format: str | None = None,
+        datetime_format: str | None = None,
+        mode: str = "w",
+        storage_options: StorageOptions | None = None,
+        if_sheet_exists: ExcelWriterIfSheetExists | None = None,
+        engine_kwargs: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> None:
+        # Use the xlsxwriter module as the Excel writer.
+        from xlsxwriter import Workbook
+
+        engine_kwargs = combine_kwargs(engine_kwargs, kwargs)
+
+        if mode == "a":
+            raise ValueError("Append mode is not supported with xlsxwriter!")
+
+        super().__init__(
+            path,
+            engine=engine,
+            date_format=date_format,
+            datetime_format=datetime_format,
+            mode=mode,
+            storage_options=storage_options,
+            if_sheet_exists=if_sheet_exists,
+            engine_kwargs=engine_kwargs,
+        )
+
+        try:
+            self._book = Workbook(self._handles.handle, **engine_kwargs)
+        except TypeError:
+            self._handles.handle.close()
+            raise
+
+    @property
+    def book(self):
+        """
+        Book instance of class xlsxwriter.Workbook.
+
+        This attribute can be used to access engine-specific features.
+        """
+        return self._book
+
+    @property
+    def sheets(self) -> dict[str, Any]:
+        result = self.book.sheetnames
+        return result
+
+    def _save(self) -> None:
+        """
+        Save workbook to disk.
+        """
+        self.book.close()
+
+    def _write_cells(
+        self,
+        cells,
+        sheet_name: str | None = None,
+        startrow: int = 0,
+        startcol: int = 0,
+        freeze_panes: tuple[int, int] | None = None,
+    ) -> None:
+        # Write the frame cells using xlsxwriter.
+        sheet_name = self._get_sheet_name(sheet_name)
+
+        wks = self.book.get_worksheet_by_name(sheet_name)
+        if wks is None:
+            wks = self.book.add_worksheet(sheet_name)
+
+        style_dict = {"null": None}
+
+        if validate_freeze_panes(freeze_panes):
+            wks.freeze_panes(*(freeze_panes))
+
+        for cell in cells:
+            val, fmt = self._value_with_fmt(cell.val)
+
+            stylekey = json.dumps(cell.style)
+            if fmt:
+                stylekey += fmt
+
+            if stylekey in style_dict:
+                style = style_dict[stylekey]
+            else:
+                style = self.book.add_format(_XlsxStyler.convert(cell.style, fmt))
+                style_dict[stylekey] = style
+
+            if cell.mergestart is not None and cell.mergeend is not None:
+                wks.merge_range(
+                    startrow + cell.row,
+                    startcol + cell.col,
+                    startrow + cell.mergestart,
+                    startcol + cell.mergeend,
+                    val,
+                    style,
+                )
+            else:
+                wks.write(startrow + cell.row, startcol + cell.col, val, style)

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

@@ -0,0 +1,9 @@
+# ruff: noqa: TCH004
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # import modules that have public classes/functions
+    from pandas.io.formats import style
+
+    # and mark only those modules as public
+    __all__ = ["style"]

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

@@ -0,0 +1,157 @@
+# GH37967: Enable the use of CSS named colors, as defined in
+# matplotlib.colors.CSS4_COLORS, when exporting to Excel.
+# This data has been copied here, instead of being imported from matplotlib,
+# not to have ``to_excel`` methods require matplotlib.
+# source: matplotlib._color_data (3.3.3)
+from __future__ import annotations
+
+CSS4_COLORS = {
+    "aliceblue": "F0F8FF",
+    "antiquewhite": "FAEBD7",
+    "aqua": "00FFFF",
+    "aquamarine": "7FFFD4",
+    "azure": "F0FFFF",
+    "beige": "F5F5DC",
+    "bisque": "FFE4C4",
+    "black": "000000",
+    "blanchedalmond": "FFEBCD",
+    "blue": "0000FF",
+    "blueviolet": "8A2BE2",
+    "brown": "A52A2A",
+    "burlywood": "DEB887",
+    "cadetblue": "5F9EA0",
+    "chartreuse": "7FFF00",
+    "chocolate": "D2691E",
+    "coral": "FF7F50",
+    "cornflowerblue": "6495ED",
+    "cornsilk": "FFF8DC",
+    "crimson": "DC143C",
+    "cyan": "00FFFF",
+    "darkblue": "00008B",
+    "darkcyan": "008B8B",
+    "darkgoldenrod": "B8860B",
+    "darkgray": "A9A9A9",
+    "darkgreen": "006400",
+    "darkgrey": "A9A9A9",
+    "darkkhaki": "BDB76B",
+    "darkmagenta": "8B008B",
+    "darkolivegreen": "556B2F",
+    "darkorange": "FF8C00",
+    "darkorchid": "9932CC",
+    "darkred": "8B0000",
+    "darksalmon": "E9967A",
+    "darkseagreen": "8FBC8F",
+    "darkslateblue": "483D8B",
+    "darkslategray": "2F4F4F",
+    "darkslategrey": "2F4F4F",
+    "darkturquoise": "00CED1",
+    "darkviolet": "9400D3",
+    "deeppink": "FF1493",
+    "deepskyblue": "00BFFF",
+    "dimgray": "696969",
+    "dimgrey": "696969",
+    "dodgerblue": "1E90FF",
+    "firebrick": "B22222",
+    "floralwhite": "FFFAF0",
+    "forestgreen": "228B22",
+    "fuchsia": "FF00FF",
+    "gainsboro": "DCDCDC",
+    "ghostwhite": "F8F8FF",
+    "gold": "FFD700",
+    "goldenrod": "DAA520",
+    "gray": "808080",
+    "green": "008000",
+    "greenyellow": "ADFF2F",
+    "grey": "808080",
+    "honeydew": "F0FFF0",
+    "hotpink": "FF69B4",
+    "indianred": "CD5C5C",
+    "indigo": "4B0082",
+    "ivory": "FFFFF0",
+    "khaki": "F0E68C",
+    "lavender": "E6E6FA",
+    "lavenderblush": "FFF0F5",
+    "lawngreen": "7CFC00",
+    "lemonchiffon": "FFFACD",
+    "lightblue": "ADD8E6",
+    "lightcoral": "F08080",
+    "lightcyan": "E0FFFF",
+    "lightgoldenrodyellow": "FAFAD2",
+    "lightgray": "D3D3D3",
+    "lightgreen": "90EE90",
+    "lightgrey": "D3D3D3",
+    "lightpink": "FFB6C1",
+    "lightsalmon": "FFA07A",
+    "lightseagreen": "20B2AA",
+    "lightskyblue": "87CEFA",
+    "lightslategray": "778899",
+    "lightslategrey": "778899",
+    "lightsteelblue": "B0C4DE",
+    "lightyellow": "FFFFE0",
+    "lime": "00FF00",
+    "limegreen": "32CD32",
+    "linen": "FAF0E6",
+    "magenta": "FF00FF",
+    "maroon": "800000",
+    "mediumaquamarine": "66CDAA",
+    "mediumblue": "0000CD",
+    "mediumorchid": "BA55D3",
+    "mediumpurple": "9370DB",
+    "mediumseagreen": "3CB371",
+    "mediumslateblue": "7B68EE",
+    "mediumspringgreen": "00FA9A",
+    "mediumturquoise": "48D1CC",
+    "mediumvioletred": "C71585",
+    "midnightblue": "191970",
+    "mintcream": "F5FFFA",
+    "mistyrose": "FFE4E1",
+    "moccasin": "FFE4B5",
+    "navajowhite": "FFDEAD",
+    "navy": "000080",
+    "oldlace": "FDF5E6",
+    "olive": "808000",
+    "olivedrab": "6B8E23",
+    "orange": "FFA500",
+    "orangered": "FF4500",
+    "orchid": "DA70D6",
+    "palegoldenrod": "EEE8AA",
+    "palegreen": "98FB98",
+    "paleturquoise": "AFEEEE",
+    "palevioletred": "DB7093",
+    "papayawhip": "FFEFD5",
+    "peachpuff": "FFDAB9",
+    "peru": "CD853F",
+    "pink": "FFC0CB",
+    "plum": "DDA0DD",
+    "powderblue": "B0E0E6",
+    "purple": "800080",
+    "rebeccapurple": "663399",
+    "red": "FF0000",
+    "rosybrown": "BC8F8F",
+    "royalblue": "4169E1",
+    "saddlebrown": "8B4513",
+    "salmon": "FA8072",
+    "sandybrown": "F4A460",
+    "seagreen": "2E8B57",
+    "seashell": "FFF5EE",
+    "sienna": "A0522D",
+    "silver": "C0C0C0",
+    "skyblue": "87CEEB",
+    "slateblue": "6A5ACD",
+    "slategray": "708090",
+    "slategrey": "708090",
+    "snow": "FFFAFA",
+    "springgreen": "00FF7F",
+    "steelblue": "4682B4",
+    "tan": "D2B48C",
+    "teal": "008080",
+    "thistle": "D8BFD8",
+    "tomato": "FF6347",
+    "turquoise": "40E0D0",
+    "violet": "EE82EE",
+    "wheat": "F5DEB3",
+    "white": "FFFFFF",
+    "whitesmoke": "F5F5F5",
+    "yellow": "FFFF00",
+    "yellowgreen": "9ACD32",
+}

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

@@ -0,0 +1,94 @@
+"""
+Internal module for console introspection
+"""
+from __future__ import annotations
+
+from shutil import get_terminal_size
+
+
+def get_console_size() -> tuple[int | None, int | None]:
+    """
+    Return console size as tuple = (width, height).
+
+    Returns (None,None) in non-interactive session.
+    """
+    from pandas import get_option
+
+    display_width = get_option("display.width")
+    display_height = get_option("display.max_rows")
+
+    # Consider
+    # interactive shell terminal, can detect term size
+    # interactive non-shell terminal (ipnb/ipqtconsole), cannot detect term
+    # size non-interactive script, should disregard term size
+
+    # in addition
+    # width,height have default values, but setting to 'None' signals
+    # should use Auto-Detection, But only in interactive shell-terminal.
+    # Simple. yeah.
+
+    if in_interactive_session():
+        if in_ipython_frontend():
+            # sane defaults for interactive non-shell terminal
+            # match default for width,height in config_init
+            from pandas._config.config import get_default_val
+
+            terminal_width = get_default_val("display.width")
+            terminal_height = get_default_val("display.max_rows")
+        else:
+            # pure terminal
+            terminal_width, terminal_height = get_terminal_size()
+    else:
+        terminal_width, terminal_height = None, None
+
+    # Note if the User sets width/Height to None (auto-detection)
+    # and we're in a script (non-inter), this will return (None,None)
+    # caller needs to deal.
+    return display_width or terminal_width, display_height or terminal_height
+
+
+# ----------------------------------------------------------------------
+# Detect our environment
+
+
+def in_interactive_session() -> bool:
+    """
+    Check if we're running in an interactive shell.
+
+    Returns
+    -------
+    bool
+        True if running under python/ipython interactive shell.
+    """
+    from pandas import get_option
+
+    def check_main():
+        try:
+            import __main__ as main
+        except ModuleNotFoundError:
+            return get_option("mode.sim_interactive")
+        return not hasattr(main, "__file__") or get_option("mode.sim_interactive")
+
+    try:
+        # error: Name '__IPYTHON__' is not defined
+        return __IPYTHON__ or check_main()  # type: ignore[name-defined]
+    except NameError:
+        return check_main()
+
+
+def in_ipython_frontend() -> bool:
+    """
+    Check if we're inside an IPython zmq frontend.
+
+    Returns
+    -------
+    bool
+    """
+    try:
+        # error: Name 'get_ipython' is not defined
+        ip = get_ipython()  # type: ignore[name-defined]
+        return "zmq" in str(type(ip)).lower()
+    except NameError:
+        pass
+
+    return False

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

@@ -0,0 +1,421 @@
+"""
+Utilities for interpreting CSS from Stylers for formatting non-HTML outputs.
+"""
+from __future__ import annotations
+
+import re
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+)
+import warnings
+
+from pandas.errors import CSSWarning
+from pandas.util._exceptions import find_stack_level
+
+if TYPE_CHECKING:
+    from collections.abc import (
+        Generator,
+        Iterable,
+        Iterator,
+    )
+
+
+def _side_expander(prop_fmt: str) -> Callable:
+    """
+    Wrapper to expand shorthand property into top, right, bottom, left properties
+
+    Parameters
+    ----------
+    side : str
+        The border side to expand into properties
+
+    Returns
+    -------
+        function: Return to call when a 'border(-{side}): {value}' string is encountered
+    """
+
+    def expand(self, prop, value: str) -> Generator[tuple[str, str], None, None]:
+        """
+        Expand shorthand property into side-specific property (top, right, bottom, left)
+
+        Parameters
+        ----------
+            prop (str): CSS property name
+            value (str): String token for property
+
+        Yields
+        ------
+            Tuple (str, str): Expanded property, value
+        """
+        tokens = value.split()
+        try:
+            mapping = self.SIDE_SHORTHANDS[len(tokens)]
+        except KeyError:
+            warnings.warn(
+                f'Could not expand "{prop}: {value}"',
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
+            return
+        for key, idx in zip(self.SIDES, mapping):
+            yield prop_fmt.format(key), tokens[idx]
+
+    return expand
+
+
+def _border_expander(side: str = "") -> Callable:
+    """
+    Wrapper to expand 'border' property into border color, style, and width properties
+
+    Parameters
+    ----------
+    side : str
+        The border side to expand into properties
+
+    Returns
+    -------
+        function: Return to call when a 'border(-{side}): {value}' string is encountered
+    """
+    if side != "":
+        side = f"-{side}"
+
+    def expand(self, prop, value: str) -> Generator[tuple[str, str], None, None]:
+        """
+        Expand border into color, style, and width tuples
+
+        Parameters
+        ----------
+            prop : str
+                CSS property name passed to styler
+            value : str
+                Value passed to styler for property
+
+        Yields
+        ------
+            Tuple (str, str): Expanded property, value
+        """
+        tokens = value.split()
+        if len(tokens) == 0 or len(tokens) > 3:
+            warnings.warn(
+                f'Too many tokens provided to "{prop}" (expected 1-3)',
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
+
+        # TODO: Can we use current color as initial value to comply with CSS standards?
+        border_declarations = {
+            f"border{side}-color": "black",
+            f"border{side}-style": "none",
+            f"border{side}-width": "medium",
+        }
+        for token in tokens:
+            if token.lower() in self.BORDER_STYLES:
+                border_declarations[f"border{side}-style"] = token
+            elif any(ratio in token.lower() for ratio in self.BORDER_WIDTH_RATIOS):
+                border_declarations[f"border{side}-width"] = token
+            else:
+                border_declarations[f"border{side}-color"] = token
+            # TODO: Warn user if item entered more than once (e.g. "border: red green")
+
+        # Per CSS, "border" will reset previous "border-*" definitions
+        yield from self.atomize(border_declarations.items())
+
+    return expand
+
+
+class CSSResolver:
+    """
+    A callable for parsing and resolving CSS to atomic properties.
+    """
+
+    UNIT_RATIOS = {
+        "pt": ("pt", 1),
+        "em": ("em", 1),
+        "rem": ("pt", 12),
+        "ex": ("em", 0.5),
+        # 'ch':
+        "px": ("pt", 0.75),
+        "pc": ("pt", 12),
+        "in": ("pt", 72),
+        "cm": ("in", 1 / 2.54),
+        "mm": ("in", 1 / 25.4),
+        "q": ("mm", 0.25),
+        "!!default": ("em", 0),
+    }
+
+    FONT_SIZE_RATIOS = UNIT_RATIOS.copy()
+    FONT_SIZE_RATIOS.update(
+        {
+            "%": ("em", 0.01),
+            "xx-small": ("rem", 0.5),
+            "x-small": ("rem", 0.625),
+            "small": ("rem", 0.8),
+            "medium": ("rem", 1),
+            "large": ("rem", 1.125),
+            "x-large": ("rem", 1.5),
+            "xx-large": ("rem", 2),
+            "smaller": ("em", 1 / 1.2),
+            "larger": ("em", 1.2),
+            "!!default": ("em", 1),
+        }
+    )
+
+    MARGIN_RATIOS = UNIT_RATIOS.copy()
+    MARGIN_RATIOS.update({"none": ("pt", 0)})
+
+    BORDER_WIDTH_RATIOS = UNIT_RATIOS.copy()
+    BORDER_WIDTH_RATIOS.update(
+        {
+            "none": ("pt", 0),
+            "thick": ("px", 4),
+            "medium": ("px", 2),
+            "thin": ("px", 1),
+            # Default: medium only if solid
+        }
+    )
+
+    BORDER_STYLES = [
+        "none",
+        "hidden",
+        "dotted",
+        "dashed",
+        "solid",
+        "double",
+        "groove",
+        "ridge",
+        "inset",
+        "outset",
+        "mediumdashdot",
+        "dashdotdot",
+        "hair",
+        "mediumdashdotdot",
+        "dashdot",
+        "slantdashdot",
+        "mediumdashed",
+    ]
+
+    SIDE_SHORTHANDS = {
+        1: [0, 0, 0, 0],
+        2: [0, 1, 0, 1],
+        3: [0, 1, 2, 1],
+        4: [0, 1, 2, 3],
+    }
+
+    SIDES = ("top", "right", "bottom", "left")
+
+    CSS_EXPANSIONS = {
+        **{
+            (f"border-{prop}" if prop else "border"): _border_expander(prop)
+            for prop in ["", "top", "right", "bottom", "left"]
+        },
+        **{
+            f"border-{prop}": _side_expander(f"border-{{:s}}-{prop}")
+            for prop in ["color", "style", "width"]
+        },
+        "margin": _side_expander("margin-{:s}"),
+        "padding": _side_expander("padding-{:s}"),
+    }
+
+    def __call__(
+        self,
+        declarations: str | Iterable[tuple[str, str]],
+        inherited: dict[str, str] | None = None,
+    ) -> dict[str, str]:
+        """
+        The given declarations to atomic properties.
+
+        Parameters
+        ----------
+        declarations_str : str | Iterable[tuple[str, str]]
+            A CSS string or set of CSS declaration tuples
+            e.g. "font-weight: bold; background: blue" or
+            {("font-weight", "bold"), ("background", "blue")}
+        inherited : dict, optional
+            Atomic properties indicating the inherited style context in which
+            declarations_str is to be resolved. ``inherited`` should already
+            be resolved, i.e. valid output of this method.
+
+        Returns
+        -------
+        dict
+            Atomic CSS 2.2 properties.
+
+        Examples
+        --------
+        >>> resolve = CSSResolver()
+        >>> inherited = {'font-family': 'serif', 'font-weight': 'bold'}
+        >>> out = resolve('''
+        ...               border-color: BLUE RED;
+        ...               font-size: 1em;
+        ...               font-size: 2em;
+        ...               font-weight: normal;
+        ...               font-weight: inherit;
+        ...               ''', inherited)
+        >>> sorted(out.items())  # doctest: +NORMALIZE_WHITESPACE
+        [('border-bottom-color', 'blue'),
+         ('border-left-color', 'red'),
+         ('border-right-color', 'red'),
+         ('border-top-color', 'blue'),
+         ('font-family', 'serif'),
+         ('font-size', '24pt'),
+         ('font-weight', 'bold')]
+        """
+        if isinstance(declarations, str):
+            declarations = self.parse(declarations)
+        props = dict(self.atomize(declarations))
+        if inherited is None:
+            inherited = {}
+
+        props = self._update_initial(props, inherited)
+        props = self._update_font_size(props, inherited)
+        return self._update_other_units(props)
+
+    def _update_initial(
+        self,
+        props: dict[str, str],
+        inherited: dict[str, str],
+    ) -> dict[str, str]:
+        # 1. resolve inherited, initial
+        for prop, val in inherited.items():
+            if prop not in props:
+                props[prop] = val
+
+        new_props = props.copy()
+        for prop, val in props.items():
+            if val == "inherit":
+                val = inherited.get(prop, "initial")
+
+            if val in ("initial", None):
+                # we do not define a complete initial stylesheet
+                del new_props[prop]
+            else:
+                new_props[prop] = val
+        return new_props
+
+    def _update_font_size(
+        self,
+        props: dict[str, str],
+        inherited: dict[str, str],
+    ) -> dict[str, str]:
+        # 2. resolve relative font size
+        if props.get("font-size"):
+            props["font-size"] = self.size_to_pt(
+                props["font-size"],
+                self._get_font_size(inherited),
+                conversions=self.FONT_SIZE_RATIOS,
+            )
+        return props
+
+    def _get_font_size(self, props: dict[str, str]) -> float | None:
+        if props.get("font-size"):
+            font_size_string = props["font-size"]
+            return self._get_float_font_size_from_pt(font_size_string)
+        return None
+
+    def _get_float_font_size_from_pt(self, font_size_string: str) -> float:
+        assert font_size_string.endswith("pt")
+        return float(font_size_string.rstrip("pt"))
+
+    def _update_other_units(self, props: dict[str, str]) -> dict[str, str]:
+        font_size = self._get_font_size(props)
+        # 3. TODO: resolve other font-relative units
+        for side in self.SIDES:
+            prop = f"border-{side}-width"
+            if prop in props:
+                props[prop] = self.size_to_pt(
+                    props[prop],
+                    em_pt=font_size,
+                    conversions=self.BORDER_WIDTH_RATIOS,
+                )
+
+            for prop in [f"margin-{side}", f"padding-{side}"]:
+                if prop in props:
+                    # TODO: support %
+                    props[prop] = self.size_to_pt(
+                        props[prop],
+                        em_pt=font_size,
+                        conversions=self.MARGIN_RATIOS,
+                    )
+        return props
+
+    def size_to_pt(self, in_val, em_pt=None, conversions=UNIT_RATIOS) -> str:
+        def _error():
+            warnings.warn(
+                f"Unhandled size: {repr(in_val)}",
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
+            return self.size_to_pt("1!!default", conversions=conversions)
+
+        match = re.match(r"^(\S*?)([a-zA-Z%!].*)", in_val)
+        if match is None:
+            return _error()
+
+        val, unit = match.groups()
+        if val == "":
+            # hack for 'large' etc.
+            val = 1
+        else:
+            try:
+                val = float(val)
+            except ValueError:
+                return _error()
+
+        while unit != "pt":
+            if unit == "em":
+                if em_pt is None:
+                    unit = "rem"
+                else:
+                    val *= em_pt
+                    unit = "pt"
+                continue
+
+            try:
+                unit, mul = conversions[unit]
+            except KeyError:
+                return _error()
+            val *= mul
+
+        val = round(val, 5)
+        if int(val) == val:
+            size_fmt = f"{int(val):d}pt"
+        else:
+            size_fmt = f"{val:f}pt"
+        return size_fmt
+
+    def atomize(self, declarations: Iterable) -> Generator[tuple[str, str], None, None]:
+        for prop, value in declarations:
+            prop = prop.lower()
+            value = value.lower()
+            if prop in self.CSS_EXPANSIONS:
+                expand = self.CSS_EXPANSIONS[prop]
+                yield from expand(self, prop, value)
+            else:
+                yield prop, value
+
+    def parse(self, declarations_str: str) -> Iterator[tuple[str, str]]:
+        """
+        Generates (prop, value) pairs from declarations.
+
+        In a future version may generate parsed tokens from tinycss/tinycss2
+
+        Parameters
+        ----------
+        declarations_str : str
+        """
+        for decl in declarations_str.split(";"):
+            if not decl.strip():
+                continue
+            prop, sep, val = decl.partition(":")
+            prop = prop.strip().lower()
+            # TODO: don't lowercase case sensitive parts of values (strings)
+            val = val.strip().lower()
+            if sep:
+                yield prop, val
+            else:
+                warnings.warn(
+                    f"Ill-formatted attribute: expected a colon in {repr(decl)}",
+                    CSSWarning,
+                    stacklevel=find_stack_level(),
+                )

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

@@ -0,0 +1,962 @@
+"""
+Utilities for conversion to writer-agnostic Excel representation.
+"""
+from __future__ import annotations
+
+from collections.abc import (
+    Hashable,
+    Iterable,
+    Mapping,
+    Sequence,
+)
+import functools
+import itertools
+import re
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    cast,
+)
+import warnings
+
+import numpy as np
+
+from pandas._libs.lib import is_list_like
+from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
+
+from pandas.core.dtypes import missing
+from pandas.core.dtypes.common import (
+    is_float,
+    is_scalar,
+)
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    PeriodIndex,
+)
+import pandas.core.common as com
+from pandas.core.shared_docs import _shared_docs
+
+from pandas.io.formats._color_data import CSS4_COLORS
+from pandas.io.formats.css import (
+    CSSResolver,
+    CSSWarning,
+)
+from pandas.io.formats.format import get_level_lengths
+from pandas.io.formats.printing import pprint_thing
+
+if TYPE_CHECKING:
+    from pandas._typing import (
+        FilePath,
+        IndexLabel,
+        StorageOptions,
+        WriteExcelBuffer,
+    )
+
+    from pandas import ExcelWriter
+
+
+class ExcelCell:
+    __fields__ = ("row", "col", "val", "style", "mergestart", "mergeend")
+    __slots__ = __fields__
+
+    def __init__(
+        self,
+        row: int,
+        col: int,
+        val,
+        style=None,
+        mergestart: int | None = None,
+        mergeend: int | None = None,
+    ) -> None:
+        self.row = row
+        self.col = col
+        self.val = val
+        self.style = style
+        self.mergestart = mergestart
+        self.mergeend = mergeend
+
+
+class CssExcelCell(ExcelCell):
+    def __init__(
+        self,
+        row: int,
+        col: int,
+        val,
+        style: dict | None,
+        css_styles: dict[tuple[int, int], list[tuple[str, Any]]] | None,
+        css_row: int,
+        css_col: int,
+        css_converter: Callable | None,
+        **kwargs,
+    ) -> None:
+        if css_styles and css_converter:
+            # Use dict to get only one (case-insensitive) declaration per property
+            declaration_dict = {
+                prop.lower(): val for prop, val in css_styles[css_row, css_col]
+            }
+            # Convert to frozenset for order-invariant caching
+            unique_declarations = frozenset(declaration_dict.items())
+            style = css_converter(unique_declarations)
+
+        super().__init__(row=row, col=col, val=val, style=style, **kwargs)
+
+
+class CSSToExcelConverter:
+    """
+    A callable for converting CSS declarations to ExcelWriter styles
+
+    Supports parts of CSS 2.2, with minimal CSS 3.0 support (e.g. text-shadow),
+    focusing on font styling, backgrounds, borders and alignment.
+
+    Operates by first computing CSS styles in a fairly generic
+    way (see :meth:`compute_css`) then determining Excel style
+    properties from CSS properties (see :meth:`build_xlstyle`).
+
+    Parameters
+    ----------
+    inherited : str, optional
+        CSS declarations understood to be the containing scope for the
+        CSS processed by :meth:`__call__`.
+    """
+
+    NAMED_COLORS = CSS4_COLORS
+
+    VERTICAL_MAP = {
+        "top": "top",
+        "text-top": "top",
+        "middle": "center",
+        "baseline": "bottom",
+        "bottom": "bottom",
+        "text-bottom": "bottom",
+        # OpenXML also has 'justify', 'distributed'
+    }
+
+    BOLD_MAP = {
+        "bold": True,
+        "bolder": True,
+        "600": True,
+        "700": True,
+        "800": True,
+        "900": True,
+        "normal": False,
+        "lighter": False,
+        "100": False,
+        "200": False,
+        "300": False,
+        "400": False,
+        "500": False,
+    }
+
+    ITALIC_MAP = {
+        "normal": False,
+        "italic": True,
+        "oblique": True,
+    }
+
+    FAMILY_MAP = {
+        "serif": 1,  # roman
+        "sans-serif": 2,  # swiss
+        "cursive": 4,  # script
+        "fantasy": 5,  # decorative
+    }
+
+    BORDER_STYLE_MAP = {
+        style.lower(): style
+        for style in [
+            "dashed",
+            "mediumDashDot",
+            "dashDotDot",
+            "hair",
+            "dotted",
+            "mediumDashDotDot",
+            "double",
+            "dashDot",
+            "slantDashDot",
+            "mediumDashed",
+        ]
+    }
+
+    # NB: Most of the methods here could be classmethods, as only __init__
+    #     and __call__ make use of instance attributes.  We leave them as
+    #     instancemethods so that users can easily experiment with extensions
+    #     without monkey-patching.
+    inherited: dict[str, str] | None
+
+    def __init__(self, inherited: str | None = None) -> None:
+        if inherited is not None:
+            self.inherited = self.compute_css(inherited)
+        else:
+            self.inherited = None
+        # We should avoid cache on the __call__ method.
+        # Otherwise once the method __call__ has been called
+        # garbage collection no longer deletes the instance.
+        self._call_cached = functools.cache(self._call_uncached)
+
+    compute_css = CSSResolver()
+
+    def __call__(
+        self, declarations: str | frozenset[tuple[str, str]]
+    ) -> dict[str, dict[str, str]]:
+        """
+        Convert CSS declarations to ExcelWriter style.
+
+        Parameters
+        ----------
+        declarations : str | frozenset[tuple[str, str]]
+            CSS string or set of CSS declaration tuples.
+            e.g. "font-weight: bold; background: blue" or
+            {("font-weight", "bold"), ("background", "blue")}
+
+        Returns
+        -------
+        xlstyle : dict
+            A style as interpreted by ExcelWriter when found in
+            ExcelCell.style.
+        """
+        return self._call_cached(declarations)
+
+    def _call_uncached(
+        self, declarations: str | frozenset[tuple[str, str]]
+    ) -> dict[str, dict[str, str]]:
+        properties = self.compute_css(declarations, self.inherited)
+        return self.build_xlstyle(properties)
+
+    def build_xlstyle(self, props: Mapping[str, str]) -> dict[str, dict[str, str]]:
+        out = {
+            "alignment": self.build_alignment(props),
+            "border": self.build_border(props),
+            "fill": self.build_fill(props),
+            "font": self.build_font(props),
+            "number_format": self.build_number_format(props),
+        }
+
+        # TODO: handle cell width and height: needs support in pandas.io.excel
+
+        def remove_none(d: dict[str, str | None]) -> None:
+            """Remove key where value is None, through nested dicts"""
+            for k, v in list(d.items()):
+                if v is None:
+                    del d[k]
+                elif isinstance(v, dict):
+                    remove_none(v)
+                    if not v:
+                        del d[k]
+
+        remove_none(out)
+        return out
+
+    def build_alignment(self, props: Mapping[str, str]) -> dict[str, bool | str | None]:
+        # TODO: text-indent, padding-left -> alignment.indent
+        return {
+            "horizontal": props.get("text-align"),
+            "vertical": self._get_vertical_alignment(props),
+            "wrap_text": self._get_is_wrap_text(props),
+        }
+
+    def _get_vertical_alignment(self, props: Mapping[str, str]) -> str | None:
+        vertical_align = props.get("vertical-align")
+        if vertical_align:
+            return self.VERTICAL_MAP.get(vertical_align)
+        return None
+
+    def _get_is_wrap_text(self, props: Mapping[str, str]) -> bool | None:
+        if props.get("white-space") is None:
+            return None
+        return bool(props["white-space"] not in ("nowrap", "pre", "pre-line"))
+
+    def build_border(
+        self, props: Mapping[str, str]
+    ) -> dict[str, dict[str, str | None]]:
+        return {
+            side: {
+                "style": self._border_style(
+                    props.get(f"border-{side}-style"),
+                    props.get(f"border-{side}-width"),
+                    self.color_to_excel(props.get(f"border-{side}-color")),
+                ),
+                "color": self.color_to_excel(props.get(f"border-{side}-color")),
+            }
+            for side in ["top", "right", "bottom", "left"]
+        }
+
+    def _border_style(self, style: str | None, width: str | None, color: str | None):
+        # convert styles and widths to openxml, one of:
+        #       'dashDot'
+        #       'dashDotDot'
+        #       'dashed'
+        #       'dotted'
+        #       'double'
+        #       'hair'
+        #       'medium'
+        #       'mediumDashDot'
+        #       'mediumDashDotDot'
+        #       'mediumDashed'
+        #       'slantDashDot'
+        #       'thick'
+        #       'thin'
+        if width is None and style is None and color is None:
+            # Return None will remove "border" from style dictionary
+            return None
+
+        if width is None and style is None:
+            # Return "none" will keep "border" in style dictionary
+            return "none"
+
+        if style in ("none", "hidden"):
+            return "none"
+
+        width_name = self._get_width_name(width)
+        if width_name is None:
+            return "none"
+
+        if style in (None, "groove", "ridge", "inset", "outset", "solid"):
+            # not handled
+            return width_name
+
+        if style == "double":
+            return "double"
+        if style == "dotted":
+            if width_name in ("hair", "thin"):
+                return "dotted"
+            return "mediumDashDotDot"
+        if style == "dashed":
+            if width_name in ("hair", "thin"):
+                return "dashed"
+            return "mediumDashed"
+        elif style in self.BORDER_STYLE_MAP:
+            # Excel-specific styles
+            return self.BORDER_STYLE_MAP[style]
+        else:
+            warnings.warn(
+                f"Unhandled border style format: {repr(style)}",
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
+            return "none"
+
+    def _get_width_name(self, width_input: str | None) -> str | None:
+        width = self._width_to_float(width_input)
+        if width < 1e-5:
+            return None
+        elif width < 1.3:
+            return "thin"
+        elif width < 2.8:
+            return "medium"
+        return "thick"
+
+    def _width_to_float(self, width: str | None) -> float:
+        if width is None:
+            width = "2pt"
+        return self._pt_to_float(width)
+
+    def _pt_to_float(self, pt_string: str) -> float:
+        assert pt_string.endswith("pt")
+        return float(pt_string.rstrip("pt"))
+
+    def build_fill(self, props: Mapping[str, str]):
+        # TODO: perhaps allow for special properties
+        #       -excel-pattern-bgcolor and -excel-pattern-type
+        fill_color = props.get("background-color")
+        if fill_color not in (None, "transparent", "none"):
+            return {"fgColor": self.color_to_excel(fill_color), "patternType": "solid"}
+
+    def build_number_format(self, props: Mapping[str, str]) -> dict[str, str | None]:
+        fc = props.get("number-format")
+        fc = fc.replace("§", ";") if isinstance(fc, str) else fc
+        return {"format_code": fc}
+
+    def build_font(
+        self, props: Mapping[str, str]
+    ) -> dict[str, bool | float | str | None]:
+        font_names = self._get_font_names(props)
+        decoration = self._get_decoration(props)
+        return {
+            "name": font_names[0] if font_names else None,
+            "family": self._select_font_family(font_names),
+            "size": self._get_font_size(props),
+            "bold": self._get_is_bold(props),
+            "italic": self._get_is_italic(props),
+            "underline": ("single" if "underline" in decoration else None),
+            "strike": ("line-through" in decoration) or None,
+            "color": self.color_to_excel(props.get("color")),
+            # shadow if nonzero digit before shadow color
+            "shadow": self._get_shadow(props),
+        }
+
+    def _get_is_bold(self, props: Mapping[str, str]) -> bool | None:
+        weight = props.get("font-weight")
+        if weight:
+            return self.BOLD_MAP.get(weight)
+        return None
+
+    def _get_is_italic(self, props: Mapping[str, str]) -> bool | None:
+        font_style = props.get("font-style")
+        if font_style:
+            return self.ITALIC_MAP.get(font_style)
+        return None
+
+    def _get_decoration(self, props: Mapping[str, str]) -> Sequence[str]:
+        decoration = props.get("text-decoration")
+        if decoration is not None:
+            return decoration.split()
+        else:
+            return ()
+
+    def _get_underline(self, decoration: Sequence[str]) -> str | None:
+        if "underline" in decoration:
+            return "single"
+        return None
+
+    def _get_shadow(self, props: Mapping[str, str]) -> bool | None:
+        if "text-shadow" in props:
+            return bool(re.search("^[^#(]*[1-9]", props["text-shadow"]))
+        return None
+
+    def _get_font_names(self, props: Mapping[str, str]) -> Sequence[str]:
+        font_names_tmp = re.findall(
+            r"""(?x)
+            (
+            "(?:[^"]|\\")+"
+            |
+            '(?:[^']|\\')+'
+            |
+            [^'",]+
+            )(?=,|\s*$)
+        """,
+            props.get("font-family", ""),
+        )
+
+        font_names = []
+        for name in font_names_tmp:
+            if name[:1] == '"':
+                name = name[1:-1].replace('\\"', '"')
+            elif name[:1] == "'":
+                name = name[1:-1].replace("\\'", "'")
+            else:
+                name = name.strip()
+            if name:
+                font_names.append(name)
+        return font_names
+
+    def _get_font_size(self, props: Mapping[str, str]) -> float | None:
+        size = props.get("font-size")
+        if size is None:
+            return size
+        return self._pt_to_float(size)
+
+    def _select_font_family(self, font_names: Sequence[str]) -> int | None:
+        family = None
+        for name in font_names:
+            family = self.FAMILY_MAP.get(name)
+            if family:
+                break
+
+        return family
+
+    def color_to_excel(self, val: str | None) -> str | None:
+        if val is None:
+            return None
+
+        if self._is_hex_color(val):
+            return self._convert_hex_to_excel(val)
+
+        try:
+            return self.NAMED_COLORS[val]
+        except KeyError:
+            warnings.warn(
+                f"Unhandled color format: {repr(val)}",
+                CSSWarning,
+                stacklevel=find_stack_level(),
+            )
+        return None
+
+    def _is_hex_color(self, color_string: str) -> bool:
+        return bool(color_string.startswith("#"))
+
+    def _convert_hex_to_excel(self, color_string: str) -> str:
+        code = color_string.lstrip("#")
+        if self._is_shorthand_color(color_string):
+            return (code[0] * 2 + code[1] * 2 + code[2] * 2).upper()
+        else:
+            return code.upper()
+
+    def _is_shorthand_color(self, color_string: str) -> bool:
+        """Check if color code is shorthand.
+
+        #FFF is a shorthand as opposed to full #FFFFFF.
+        """
+        code = color_string.lstrip("#")
+        if len(code) == 3:
+            return True
+        elif len(code) == 6:
+            return False
+        else:
+            raise ValueError(f"Unexpected color {color_string}")
+
+
+class ExcelFormatter:
+    """
+    Class for formatting a DataFrame to a list of ExcelCells,
+
+    Parameters
+    ----------
+    df : DataFrame or Styler
+    na_rep: na representation
+    float_format : str, default None
+        Format string for floating point numbers
+    cols : sequence, optional
+        Columns to write
+    header : bool or sequence of str, default True
+        Write out column names. If a list of string is given it is
+        assumed to be aliases for the column names
+    index : bool, default True
+        output row names (index)
+    index_label : str or sequence, default None
+        Column label for index column(s) if desired. If None is given, and
+        `header` and `index` are True, then the index names are used. A
+        sequence should be given if the DataFrame uses MultiIndex.
+    merge_cells : bool, default False
+        Format MultiIndex and Hierarchical Rows as merged cells.
+    inf_rep : str, default `'inf'`
+        representation for np.inf values (which aren't representable in Excel)
+        A `'-'` sign will be added in front of -inf.
+    style_converter : callable, optional
+        This translates Styler styles (CSS) into ExcelWriter styles.
+        Defaults to ``CSSToExcelConverter()``.
+        It should have signature css_declarations string -> excel style.
+        This is only called for body cells.
+    """
+
+    max_rows = 2**20
+    max_cols = 2**14
+
+    def __init__(
+        self,
+        df,
+        na_rep: str = "",
+        float_format: str | None = None,
+        cols: Sequence[Hashable] | None = None,
+        header: Sequence[Hashable] | bool = True,
+        index: bool = True,
+        index_label: IndexLabel | None = None,
+        merge_cells: bool = False,
+        inf_rep: str = "inf",
+        style_converter: Callable | None = None,
+    ) -> None:
+        self.rowcounter = 0
+        self.na_rep = na_rep
+        if not isinstance(df, DataFrame):
+            self.styler = df
+            self.styler._compute()  # calculate applied styles
+            df = df.data
+            if style_converter is None:
+                style_converter = CSSToExcelConverter()
+            self.style_converter: Callable | None = style_converter
+        else:
+            self.styler = None
+            self.style_converter = None
+        self.df = df
+        if cols is not None:
+            # all missing, raise
+            if not len(Index(cols).intersection(df.columns)):
+                raise KeyError("passes columns are not ALL present dataframe")
+
+            if len(Index(cols).intersection(df.columns)) != len(set(cols)):
+                # Deprecated in GH#17295, enforced in 1.0.0
+                raise KeyError("Not all names specified in 'columns' are found")
+
+            self.df = df.reindex(columns=cols)
+
+        self.columns = self.df.columns
+        self.float_format = float_format
+        self.index = index
+        self.index_label = index_label
+        self.header = header
+        self.merge_cells = merge_cells
+        self.inf_rep = inf_rep
+
+    @property
+    def header_style(self) -> dict[str, dict[str, str | bool]]:
+        return {
+            "font": {"bold": True},
+            "borders": {
+                "top": "thin",
+                "right": "thin",
+                "bottom": "thin",
+                "left": "thin",
+            },
+            "alignment": {"horizontal": "center", "vertical": "top"},
+        }
+
+    def _format_value(self, val):
+        if is_scalar(val) and missing.isna(val):
+            val = self.na_rep
+        elif is_float(val):
+            if missing.isposinf_scalar(val):
+                val = self.inf_rep
+            elif missing.isneginf_scalar(val):
+                val = f"-{self.inf_rep}"
+            elif self.float_format is not None:
+                val = float(self.float_format % val)
+        if getattr(val, "tzinfo", None) is not None:
+            raise ValueError(
+                "Excel does not support datetimes with "
+                "timezones. Please ensure that datetimes "
+                "are timezone unaware before writing to Excel."
+            )
+        return val
+
+    def _format_header_mi(self) -> Iterable[ExcelCell]:
+        if self.columns.nlevels > 1:
+            if not self.index:
+                raise NotImplementedError(
+                    "Writing to Excel with MultiIndex columns and no "
+                    "index ('index'=False) is not yet implemented."
+                )
+
+        if not (self._has_aliases or self.header):
+            return
+
+        columns = self.columns
+        level_strs = columns._format_multi(
+            sparsify=self.merge_cells, include_names=False
+        )
+        level_lengths = get_level_lengths(level_strs)
+        coloffset = 0
+        lnum = 0
+
+        if self.index and isinstance(self.df.index, MultiIndex):
+            coloffset = len(self.df.index[0]) - 1
+
+        if self.merge_cells:
+            # Format multi-index as a merged cells.
+            for lnum, name in enumerate(columns.names):
+                yield ExcelCell(
+                    row=lnum,
+                    col=coloffset,
+                    val=name,
+                    style=self.header_style,
+                )
+
+            for lnum, (spans, levels, level_codes) in enumerate(
+                zip(level_lengths, columns.levels, columns.codes)
+            ):
+                values = levels.take(level_codes)
+                for i, span_val in spans.items():
+                    mergestart, mergeend = None, None
+                    if span_val > 1:
+                        mergestart, mergeend = lnum, coloffset + i + span_val
+                    yield CssExcelCell(
+                        row=lnum,
+                        col=coloffset + i + 1,
+                        val=values[i],
+                        style=self.header_style,
+                        css_styles=getattr(self.styler, "ctx_columns", None),
+                        css_row=lnum,
+                        css_col=i,
+                        css_converter=self.style_converter,
+                        mergestart=mergestart,
+                        mergeend=mergeend,
+                    )
+        else:
+            # Format in legacy format with dots to indicate levels.
+            for i, values in enumerate(zip(*level_strs)):
+                v = ".".join(map(pprint_thing, values))
+                yield CssExcelCell(
+                    row=lnum,
+                    col=coloffset + i + 1,
+                    val=v,
+                    style=self.header_style,
+                    css_styles=getattr(self.styler, "ctx_columns", None),
+                    css_row=lnum,
+                    css_col=i,
+                    css_converter=self.style_converter,
+                )
+
+        self.rowcounter = lnum
+
+    def _format_header_regular(self) -> Iterable[ExcelCell]:
+        if self._has_aliases or self.header:
+            coloffset = 0
+
+            if self.index:
+                coloffset = 1
+                if isinstance(self.df.index, MultiIndex):
+                    coloffset = len(self.df.index.names)
+
+            colnames = self.columns
+            if self._has_aliases:
+                self.header = cast(Sequence, self.header)
+                if len(self.header) != len(self.columns):
+                    raise ValueError(
+                        f"Writing {len(self.columns)} cols "
+                        f"but got {len(self.header)} aliases"
+                    )
+                colnames = self.header
+
+            for colindex, colname in enumerate(colnames):
+                yield CssExcelCell(
+                    row=self.rowcounter,
+                    col=colindex + coloffset,
+                    val=colname,
+                    style=self.header_style,
+                    css_styles=getattr(self.styler, "ctx_columns", None),
+                    css_row=0,
+                    css_col=colindex,
+                    css_converter=self.style_converter,
+                )
+
+    def _format_header(self) -> Iterable[ExcelCell]:
+        gen: Iterable[ExcelCell]
+
+        if isinstance(self.columns, MultiIndex):
+            gen = self._format_header_mi()
+        else:
+            gen = self._format_header_regular()
+
+        gen2: Iterable[ExcelCell] = ()
+
+        if self.df.index.names:
+            row = [x if x is not None else "" for x in self.df.index.names] + [
+                ""
+            ] * len(self.columns)
+            if functools.reduce(lambda x, y: x and y, (x != "" for x in row)):
+                gen2 = (
+                    ExcelCell(self.rowcounter, colindex, val, self.header_style)
+                    for colindex, val in enumerate(row)
+                )
+                self.rowcounter += 1
+        return itertools.chain(gen, gen2)
+
+    def _format_body(self) -> Iterable[ExcelCell]:
+        if isinstance(self.df.index, MultiIndex):
+            return self._format_hierarchical_rows()
+        else:
+            return self._format_regular_rows()
+
+    def _format_regular_rows(self) -> Iterable[ExcelCell]:
+        if self._has_aliases or self.header:
+            self.rowcounter += 1
+
+        # output index and index_label?
+        if self.index:
+            # check aliases
+            # if list only take first as this is not a MultiIndex
+            if self.index_label and isinstance(
+                self.index_label, (list, tuple, np.ndarray, Index)
+            ):
+                index_label = self.index_label[0]
+            # if string good to go
+            elif self.index_label and isinstance(self.index_label, str):
+                index_label = self.index_label
+            else:
+                index_label = self.df.index.names[0]
+
+            if isinstance(self.columns, MultiIndex):
+                self.rowcounter += 1
+
+            if index_label and self.header is not False:
+                yield ExcelCell(self.rowcounter - 1, 0, index_label, self.header_style)
+
+            # write index_values
+            index_values = self.df.index
+            if isinstance(self.df.index, PeriodIndex):
+                index_values = self.df.index.to_timestamp()
+
+            for idx, idxval in enumerate(index_values):
+                yield CssExcelCell(
+                    row=self.rowcounter + idx,
+                    col=0,
+                    val=idxval,
+                    style=self.header_style,
+                    css_styles=getattr(self.styler, "ctx_index", None),
+                    css_row=idx,
+                    css_col=0,
+                    css_converter=self.style_converter,
+                )
+            coloffset = 1
+        else:
+            coloffset = 0
+
+        yield from self._generate_body(coloffset)
+
+    def _format_hierarchical_rows(self) -> Iterable[ExcelCell]:
+        if self._has_aliases or self.header:
+            self.rowcounter += 1
+
+        gcolidx = 0
+
+        if self.index:
+            index_labels = self.df.index.names
+            # check for aliases
+            if self.index_label and isinstance(
+                self.index_label, (list, tuple, np.ndarray, Index)
+            ):
+                index_labels = self.index_label
+
+            # MultiIndex columns require an extra row
+            # with index names (blank if None) for
+            # unambiguous round-trip, unless not merging,
+            # in which case the names all go on one row Issue #11328
+            if isinstance(self.columns, MultiIndex) and self.merge_cells:
+                self.rowcounter += 1
+
+            # if index labels are not empty go ahead and dump
+            if com.any_not_none(*index_labels) and self.header is not False:
+                for cidx, name in enumerate(index_labels):
+                    yield ExcelCell(self.rowcounter - 1, cidx, name, self.header_style)
+
+            if self.merge_cells:
+                # Format hierarchical rows as merged cells.
+                level_strs = self.df.index._format_multi(
+                    sparsify=True, include_names=False
+                )
+                level_lengths = get_level_lengths(level_strs)
+
+                for spans, levels, level_codes in zip(
+                    level_lengths, self.df.index.levels, self.df.index.codes
+                ):
+                    values = levels.take(
+                        level_codes,
+                        allow_fill=levels._can_hold_na,
+                        fill_value=levels._na_value,
+                    )
+
+                    for i, span_val in spans.items():
+                        mergestart, mergeend = None, None
+                        if span_val > 1:
+                            mergestart = self.rowcounter + i + span_val - 1
+                            mergeend = gcolidx
+                        yield CssExcelCell(
+                            row=self.rowcounter + i,
+                            col=gcolidx,
+                            val=values[i],
+                            style=self.header_style,
+                            css_styles=getattr(self.styler, "ctx_index", None),
+                            css_row=i,
+                            css_col=gcolidx,
+                            css_converter=self.style_converter,
+                            mergestart=mergestart,
+                            mergeend=mergeend,
+                        )
+                    gcolidx += 1
+
+            else:
+                # Format hierarchical rows with non-merged values.
+                for indexcolvals in zip(*self.df.index):
+                    for idx, indexcolval in enumerate(indexcolvals):
+                        yield CssExcelCell(
+                            row=self.rowcounter + idx,
+                            col=gcolidx,
+                            val=indexcolval,
+                            style=self.header_style,
+                            css_styles=getattr(self.styler, "ctx_index", None),
+                            css_row=idx,
+                            css_col=gcolidx,
+                            css_converter=self.style_converter,
+                        )
+                    gcolidx += 1
+
+        yield from self._generate_body(gcolidx)
+
+    @property
+    def _has_aliases(self) -> bool:
+        """Whether the aliases for column names are present."""
+        return is_list_like(self.header)
+
+    def _generate_body(self, coloffset: int) -> Iterable[ExcelCell]:
+        # Write the body of the frame data series by series.
+        for colidx in range(len(self.columns)):
+            series = self.df.iloc[:, colidx]
+            for i, val in enumerate(series):
+                yield CssExcelCell(
+                    row=self.rowcounter + i,
+                    col=colidx + coloffset,
+                    val=val,
+                    style=None,
+                    css_styles=getattr(self.styler, "ctx", None),
+                    css_row=i,
+                    css_col=colidx,
+                    css_converter=self.style_converter,
+                )
+
+    def get_formatted_cells(self) -> Iterable[ExcelCell]:
+        for cell in itertools.chain(self._format_header(), self._format_body()):
+            cell.val = self._format_value(cell.val)
+            yield cell
+
+    @doc(storage_options=_shared_docs["storage_options"])
+    def write(
+        self,
+        writer: FilePath | WriteExcelBuffer | ExcelWriter,
+        sheet_name: str = "Sheet1",
+        startrow: int = 0,
+        startcol: int = 0,
+        freeze_panes: tuple[int, int] | None = None,
+        engine: str | None = None,
+        storage_options: StorageOptions | None = None,
+        engine_kwargs: dict | None = None,
+    ) -> None:
+        """
+        writer : path-like, file-like, or ExcelWriter object
+            File path or existing ExcelWriter
+        sheet_name : str, default 'Sheet1'
+            Name of sheet which will contain DataFrame
+        startrow :
+            upper left cell row to dump data frame
+        startcol :
+            upper left cell column to dump data frame
+        freeze_panes : tuple of integer (length 2), default None
+            Specifies the one-based bottommost row and rightmost column that
+            is to be frozen
+        engine : string, default None
+            write engine to use if writer is a path - you can also set this
+            via the options ``io.excel.xlsx.writer``,
+            or ``io.excel.xlsm.writer``.
+
+        {storage_options}
+
+        engine_kwargs: dict, optional
+            Arbitrary keyword arguments passed to excel engine.
+        """
+        from pandas.io.excel import ExcelWriter
+
+        num_rows, num_cols = self.df.shape
+        if num_rows > self.max_rows or num_cols > self.max_cols:
+            raise ValueError(
+                f"This sheet is too large! Your sheet size is: {num_rows}, {num_cols} "
+                f"Max sheet size is: {self.max_rows}, {self.max_cols}"
+            )
+
+        if engine_kwargs is None:
+            engine_kwargs = {}
+
+        formatted_cells = self.get_formatted_cells()
+        if isinstance(writer, ExcelWriter):
+            need_save = False
+        else:
+            writer = ExcelWriter(
+                writer,
+                engine=engine,
+                storage_options=storage_options,
+                engine_kwargs=engine_kwargs,
+            )
+            need_save = True
+
+        try:
+            writer._write_cells(
+                formatted_cells,
+                sheet_name,
+                startrow=startrow,
+                startcol=startcol,
+                freeze_panes=freeze_panes,
+            )
+        finally:
+            # make sure to close opened file handles
+            if need_save:
+                writer.close()

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

@@ -0,0 +1,2058 @@
+"""
+Internal module for formatting output data in csv, html, xml,
+and latex files. This module also applies to display formatting.
+"""
+from __future__ import annotations
+
+from collections.abc import (
+    Generator,
+    Hashable,
+    Mapping,
+    Sequence,
+)
+from contextlib import contextmanager
+from csv import QUOTE_NONE
+from decimal import Decimal
+from functools import partial
+from io import StringIO
+import math
+import re
+from shutil import get_terminal_size
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Final,
+    cast,
+)
+
+import numpy as np
+
+from pandas._config.config import (
+    get_option,
+    set_option,
+)
+
+from pandas._libs import lib
+from pandas._libs.missing import NA
+from pandas._libs.tslibs import (
+    NaT,
+    Timedelta,
+    Timestamp,
+)
+from pandas._libs.tslibs.nattype import NaTType
+
+from pandas.core.dtypes.common import (
+    is_complex_dtype,
+    is_float,
+    is_integer,
+    is_list_like,
+    is_numeric_dtype,
+    is_scalar,
+)
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    DatetimeTZDtype,
+    ExtensionDtype,
+)
+from pandas.core.dtypes.missing import (
+    isna,
+    notna,
+)
+
+from pandas.core.arrays import (
+    Categorical,
+    DatetimeArray,
+    ExtensionArray,
+    TimedeltaArray,
+)
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.base import PandasObject
+import pandas.core.common as com
+from pandas.core.indexes.api import (
+    Index,
+    MultiIndex,
+    PeriodIndex,
+    ensure_index,
+)
+from pandas.core.indexes.datetimes import DatetimeIndex
+from pandas.core.indexes.timedeltas import TimedeltaIndex
+from pandas.core.reshape.concat import concat
+
+from pandas.io.common import (
+    check_parent_directory,
+    stringify_path,
+)
+from pandas.io.formats import printing
+
+if TYPE_CHECKING:
+    from pandas._typing import (
+        ArrayLike,
+        Axes,
+        ColspaceArgType,
+        ColspaceType,
+        CompressionOptions,
+        FilePath,
+        FloatFormatType,
+        FormattersType,
+        IndexLabel,
+        SequenceNotStr,
+        StorageOptions,
+        WriteBuffer,
+    )
+
+    from pandas import (
+        DataFrame,
+        Series,
+    )
+
+
+common_docstring: Final = """
+        Parameters
+        ----------
+        buf : str, Path or StringIO-like, optional, default None
+            Buffer to write to. If None, the output is returned as a string.
+        columns : array-like, optional, default None
+            The subset of columns to write. Writes all columns by default.
+        col_space : %(col_space_type)s, optional
+            %(col_space)s.
+        header : %(header_type)s, optional
+            %(header)s.
+        index : bool, optional, default True
+            Whether to print index (row) labels.
+        na_rep : str, optional, default 'NaN'
+            String representation of ``NaN`` to use.
+        formatters : list, tuple or dict of one-param. functions, optional
+            Formatter functions to apply to columns' elements by position or
+            name.
+            The result of each function must be a unicode string.
+            List/tuple must be of length equal to the number of columns.
+        float_format : one-parameter function, optional, default None
+            Formatter function to apply to columns' elements if they are
+            floats. This function must return a unicode string and will be
+            applied only to the non-``NaN`` elements, with ``NaN`` being
+            handled by ``na_rep``.
+        sparsify : bool, optional, default True
+            Set to False for a DataFrame with a hierarchical index to print
+            every multiindex key at each row.
+        index_names : bool, optional, default True
+            Prints the names of the indexes.
+        justify : str, default None
+            How to justify the column labels. If None uses the option from
+            the print configuration (controlled by set_option), 'right' out
+            of the box. Valid values are
+
+            * left
+            * right
+            * center
+            * justify
+            * justify-all
+            * start
+            * end
+            * inherit
+            * match-parent
+            * initial
+            * unset.
+        max_rows : int, optional
+            Maximum number of rows to display in the console.
+        max_cols : int, optional
+            Maximum number of columns to display in the console.
+        show_dimensions : bool, default False
+            Display DataFrame dimensions (number of rows by number of columns).
+        decimal : str, default '.'
+            Character recognized as decimal separator, e.g. ',' in Europe.
+    """
+
+VALID_JUSTIFY_PARAMETERS = (
+    "left",
+    "right",
+    "center",
+    "justify",
+    "justify-all",
+    "start",
+    "end",
+    "inherit",
+    "match-parent",
+    "initial",
+    "unset",
+)
+
+return_docstring: Final = """
+        Returns
+        -------
+        str or None
+            If buf is None, returns the result as a string. Otherwise returns
+            None.
+    """
+
+
+class SeriesFormatter:
+    """
+    Implement the main logic of Series.to_string, which underlies
+    Series.__repr__.
+    """
+
+    def __init__(
+        self,
+        series: Series,
+        *,
+        length: bool | str = True,
+        header: bool = True,
+        index: bool = True,
+        na_rep: str = "NaN",
+        name: bool = False,
+        float_format: str | None = None,
+        dtype: bool = True,
+        max_rows: int | None = None,
+        min_rows: int | None = None,
+    ) -> None:
+        self.series = series
+        self.buf = StringIO()
+        self.name = name
+        self.na_rep = na_rep
+        self.header = header
+        self.length = length
+        self.index = index
+        self.max_rows = max_rows
+        self.min_rows = min_rows
+
+        if float_format is None:
+            float_format = get_option("display.float_format")
+        self.float_format = float_format
+        self.dtype = dtype
+        self.adj = printing.get_adjustment()
+
+        self._chk_truncate()
+
+    def _chk_truncate(self) -> None:
+        self.tr_row_num: int | None
+
+        min_rows = self.min_rows
+        max_rows = self.max_rows
+        # truncation determined by max_rows, actual truncated number of rows
+        # used below by min_rows
+        is_truncated_vertically = max_rows and (len(self.series) > max_rows)
+        series = self.series
+        if is_truncated_vertically:
+            max_rows = cast(int, max_rows)
+            if min_rows:
+                # if min_rows is set (not None or 0), set max_rows to minimum
+                # of both
+                max_rows = min(min_rows, max_rows)
+            if max_rows == 1:
+                row_num = max_rows
+                series = series.iloc[:max_rows]
+            else:
+                row_num = max_rows // 2
+                series = concat((series.iloc[:row_num], series.iloc[-row_num:]))
+            self.tr_row_num = row_num
+        else:
+            self.tr_row_num = None
+        self.tr_series = series
+        self.is_truncated_vertically = is_truncated_vertically
+
+    def _get_footer(self) -> str:
+        name = self.series.name
+        footer = ""
+
+        index = self.series.index
+        if (
+            isinstance(index, (DatetimeIndex, PeriodIndex, TimedeltaIndex))
+            and index.freq is not None
+        ):
+            footer += f"Freq: {index.freqstr}"
+
+        if self.name is not False and name is not None:
+            if footer:
+                footer += ", "
+
+            series_name = printing.pprint_thing(name, escape_chars=("\t", "\r", "\n"))
+            footer += f"Name: {series_name}"
+
+        if self.length is True or (
+            self.length == "truncate" and self.is_truncated_vertically
+        ):
+            if footer:
+                footer += ", "
+            footer += f"Length: {len(self.series)}"
+
+        if self.dtype is not False and self.dtype is not None:
+            dtype_name = getattr(self.tr_series.dtype, "name", None)
+            if dtype_name:
+                if footer:
+                    footer += ", "
+                footer += f"dtype: {printing.pprint_thing(dtype_name)}"
+
+        # level infos are added to the end and in a new line, like it is done
+        # for Categoricals
+        if isinstance(self.tr_series.dtype, CategoricalDtype):
+            level_info = self.tr_series._values._get_repr_footer()
+            if footer:
+                footer += "\n"
+            footer += level_info
+
+        return str(footer)
+
+    def _get_formatted_values(self) -> list[str]:
+        return format_array(
+            self.tr_series._values,
+            None,
+            float_format=self.float_format,
+            na_rep=self.na_rep,
+            leading_space=self.index,
+        )
+
+    def to_string(self) -> str:
+        series = self.tr_series
+        footer = self._get_footer()
+
+        if len(series) == 0:
+            return f"{type(self.series).__name__}([], {footer})"
+
+        index = series.index
+        have_header = _has_names(index)
+        if isinstance(index, MultiIndex):
+            fmt_index = index._format_multi(include_names=True, sparsify=None)
+            adj = printing.get_adjustment()
+            fmt_index = adj.adjoin(2, *fmt_index).split("\n")
+        else:
+            fmt_index = index._format_flat(include_name=True)
+        fmt_values = self._get_formatted_values()
+
+        if self.is_truncated_vertically:
+            n_header_rows = 0
+            row_num = self.tr_row_num
+            row_num = cast(int, row_num)
+            width = self.adj.len(fmt_values[row_num - 1])
+            if width > 3:
+                dot_str = "..."
+            else:
+                dot_str = ".."
+            # Series uses mode=center because it has single value columns
+            # DataFrame uses mode=left
+            dot_str = self.adj.justify([dot_str], width, mode="center")[0]
+            fmt_values.insert(row_num + n_header_rows, dot_str)
+            fmt_index.insert(row_num + 1, "")
+
+        if self.index:
+            result = self.adj.adjoin(3, *[fmt_index[1:], fmt_values])
+        else:
+            result = self.adj.adjoin(3, fmt_values)
+
+        if self.header and have_header:
+            result = fmt_index[0] + "\n" + result
+
+        if footer:
+            result += "\n" + footer
+
+        return str("".join(result))
+
+
+def get_dataframe_repr_params() -> dict[str, Any]:
+    """Get the parameters used to repr(dataFrame) calls using DataFrame.to_string.
+
+    Supplying these parameters to DataFrame.to_string is equivalent to calling
+    ``repr(DataFrame)``. This is useful if you want to adjust the repr output.
+
+    .. versionadded:: 1.4.0
+
+    Example
+    -------
+    >>> import pandas as pd
+    >>>
+    >>> df = pd.DataFrame([[1, 2], [3, 4]])
+    >>> repr_params = pd.io.formats.format.get_dataframe_repr_params()
+    >>> repr(df) == df.to_string(**repr_params)
+    True
+    """
+    from pandas.io.formats import console
+
+    if get_option("display.expand_frame_repr"):
+        line_width, _ = console.get_console_size()
+    else:
+        line_width = None
+    return {
+        "max_rows": get_option("display.max_rows"),
+        "min_rows": get_option("display.min_rows"),
+        "max_cols": get_option("display.max_columns"),
+        "max_colwidth": get_option("display.max_colwidth"),
+        "show_dimensions": get_option("display.show_dimensions"),
+        "line_width": line_width,
+    }
+
+
+def get_series_repr_params() -> dict[str, Any]:
+    """Get the parameters used to repr(Series) calls using Series.to_string.
+
+    Supplying these parameters to Series.to_string is equivalent to calling
+    ``repr(series)``. This is useful if you want to adjust the series repr output.
+
+    .. versionadded:: 1.4.0
+
+    Example
+    -------
+    >>> import pandas as pd
+    >>>
+    >>> ser = pd.Series([1, 2, 3, 4])
+    >>> repr_params = pd.io.formats.format.get_series_repr_params()
+    >>> repr(ser) == ser.to_string(**repr_params)
+    True
+    """
+    width, height = get_terminal_size()
+    max_rows_opt = get_option("display.max_rows")
+    max_rows = height if max_rows_opt == 0 else max_rows_opt
+    min_rows = height if max_rows_opt == 0 else get_option("display.min_rows")
+
+    return {
+        "name": True,
+        "dtype": True,
+        "min_rows": min_rows,
+        "max_rows": max_rows,
+        "length": get_option("display.show_dimensions"),
+    }
+
+
+class DataFrameFormatter:
+    """
+    Class for processing dataframe formatting options and data.
+
+    Used by DataFrame.to_string, which backs DataFrame.__repr__.
+    """
+
+    __doc__ = __doc__ if __doc__ else ""
+    __doc__ += common_docstring + return_docstring
+
+    def __init__(
+        self,
+        frame: DataFrame,
+        columns: Axes | None = None,
+        col_space: ColspaceArgType | None = None,
+        header: bool | SequenceNotStr[str] = True,
+        index: bool = True,
+        na_rep: str = "NaN",
+        formatters: FormattersType | None = None,
+        justify: str | None = None,
+        float_format: FloatFormatType | None = None,
+        sparsify: bool | None = None,
+        index_names: bool = True,
+        max_rows: int | None = None,
+        min_rows: int | None = None,
+        max_cols: int | None = None,
+        show_dimensions: bool | str = False,
+        decimal: str = ".",
+        bold_rows: bool = False,
+        escape: bool = True,
+    ) -> None:
+        self.frame = frame
+        self.columns = self._initialize_columns(columns)
+        self.col_space = self._initialize_colspace(col_space)
+        self.header = header
+        self.index = index
+        self.na_rep = na_rep
+        self.formatters = self._initialize_formatters(formatters)
+        self.justify = self._initialize_justify(justify)
+        self.float_format = float_format
+        self.sparsify = self._initialize_sparsify(sparsify)
+        self.show_index_names = index_names
+        self.decimal = decimal
+        self.bold_rows = bold_rows
+        self.escape = escape
+        self.max_rows = max_rows
+        self.min_rows = min_rows
+        self.max_cols = max_cols
+        self.show_dimensions = show_dimensions
+
+        self.max_cols_fitted = self._calc_max_cols_fitted()
+        self.max_rows_fitted = self._calc_max_rows_fitted()
+
+        self.tr_frame = self.frame
+        self.truncate()
+        self.adj = printing.get_adjustment()
+
+    def get_strcols(self) -> list[list[str]]:
+        """
+        Render a DataFrame to a list of columns (as lists of strings).
+        """
+        strcols = self._get_strcols_without_index()
+
+        if self.index:
+            str_index = self._get_formatted_index(self.tr_frame)
+            strcols.insert(0, str_index)
+
+        return strcols
+
+    @property
+    def should_show_dimensions(self) -> bool:
+        return self.show_dimensions is True or (
+            self.show_dimensions == "truncate" and self.is_truncated
+        )
+
+    @property
+    def is_truncated(self) -> bool:
+        return bool(self.is_truncated_horizontally or self.is_truncated_vertically)
+
+    @property
+    def is_truncated_horizontally(self) -> bool:
+        return bool(self.max_cols_fitted and (len(self.columns) > self.max_cols_fitted))
+
+    @property
+    def is_truncated_vertically(self) -> bool:
+        return bool(self.max_rows_fitted and (len(self.frame) > self.max_rows_fitted))
+
+    @property
+    def dimensions_info(self) -> str:
+        return f"\n\n[{len(self.frame)} rows x {len(self.frame.columns)} columns]"
+
+    @property
+    def has_index_names(self) -> bool:
+        return _has_names(self.frame.index)
+
+    @property
+    def has_column_names(self) -> bool:
+        return _has_names(self.frame.columns)
+
+    @property
+    def show_row_idx_names(self) -> bool:
+        return all((self.has_index_names, self.index, self.show_index_names))
+
+    @property
+    def show_col_idx_names(self) -> bool:
+        return all((self.has_column_names, self.show_index_names, self.header))
+
+    @property
+    def max_rows_displayed(self) -> int:
+        return min(self.max_rows or len(self.frame), len(self.frame))
+
+    def _initialize_sparsify(self, sparsify: bool | None) -> bool:
+        if sparsify is None:
+            return get_option("display.multi_sparse")
+        return sparsify
+
+    def _initialize_formatters(
+        self, formatters: FormattersType | None
+    ) -> FormattersType:
+        if formatters is None:
+            return {}
+        elif len(self.frame.columns) == len(formatters) or isinstance(formatters, dict):
+            return formatters
+        else:
+            raise ValueError(
+                f"Formatters length({len(formatters)}) should match "
+                f"DataFrame number of columns({len(self.frame.columns)})"
+            )
+
+    def _initialize_justify(self, justify: str | None) -> str:
+        if justify is None:
+            return get_option("display.colheader_justify")
+        else:
+            return justify
+
+    def _initialize_columns(self, columns: Axes | None) -> Index:
+        if columns is not None:
+            cols = ensure_index(columns)
+            self.frame = self.frame[cols]
+            return cols
+        else:
+            return self.frame.columns
+
+    def _initialize_colspace(self, col_space: ColspaceArgType | None) -> ColspaceType:
+        result: ColspaceType
+
+        if col_space is None:
+            result = {}
+        elif isinstance(col_space, (int, str)):
+            result = {"": col_space}
+            result.update({column: col_space for column in self.frame.columns})
+        elif isinstance(col_space, Mapping):
+            for column in col_space.keys():
+                if column not in self.frame.columns and column != "":
+                    raise ValueError(
+                        f"Col_space is defined for an unknown column: {column}"
+                    )
+            result = col_space
+        else:
+            if len(self.frame.columns) != len(col_space):
+                raise ValueError(
+                    f"Col_space length({len(col_space)}) should match "
+                    f"DataFrame number of columns({len(self.frame.columns)})"
+                )
+            result = dict(zip(self.frame.columns, col_space))
+        return result
+
+    def _calc_max_cols_fitted(self) -> int | None:
+        """Number of columns fitting the screen."""
+        if not self._is_in_terminal():
+            return self.max_cols
+
+        width, _ = get_terminal_size()
+        if self._is_screen_narrow(width):
+            return width
+        else:
+            return self.max_cols
+
+    def _calc_max_rows_fitted(self) -> int | None:
+        """Number of rows with data fitting the screen."""
+        max_rows: int | None
+
+        if self._is_in_terminal():
+            _, height = get_terminal_size()
+            if self.max_rows == 0:
+                # rows available to fill with actual data
+                return height - self._get_number_of_auxiliary_rows()
+
+            if self._is_screen_short(height):
+                max_rows = height
+            else:
+                max_rows = self.max_rows
+        else:
+            max_rows = self.max_rows
+
+        return self._adjust_max_rows(max_rows)
+
+    def _adjust_max_rows(self, max_rows: int | None) -> int | None:
+        """Adjust max_rows using display logic.
+
+        See description here:
+        https://pandas.pydata.org/docs/dev/user_guide/options.html#frequently-used-options
+
+        GH #37359
+        """
+        if max_rows:
+            if (len(self.frame) > max_rows) and self.min_rows:
+                # if truncated, set max_rows showed to min_rows
+                max_rows = min(self.min_rows, max_rows)
+        return max_rows
+
+    def _is_in_terminal(self) -> bool:
+        """Check if the output is to be shown in terminal."""
+        return bool(self.max_cols == 0 or self.max_rows == 0)
+
+    def _is_screen_narrow(self, max_width) -> bool:
+        return bool(self.max_cols == 0 and len(self.frame.columns) > max_width)
+
+    def _is_screen_short(self, max_height) -> bool:
+        return bool(self.max_rows == 0 and len(self.frame) > max_height)
+
+    def _get_number_of_auxiliary_rows(self) -> int:
+        """Get number of rows occupied by prompt, dots and dimension info."""
+        dot_row = 1
+        prompt_row = 1
+        num_rows = dot_row + prompt_row
+
+        if self.show_dimensions:
+            num_rows += len(self.dimensions_info.splitlines())
+
+        if self.header:
+            num_rows += 1
+
+        return num_rows
+
+    def truncate(self) -> None:
+        """
+        Check whether the frame should be truncated. If so, slice the frame up.
+        """
+        if self.is_truncated_horizontally:
+            self._truncate_horizontally()
+
+        if self.is_truncated_vertically:
+            self._truncate_vertically()
+
+    def _truncate_horizontally(self) -> None:
+        """Remove columns, which are not to be displayed and adjust formatters.
+
+        Attributes affected:
+            - tr_frame
+            - formatters
+            - tr_col_num
+        """
+        assert self.max_cols_fitted is not None
+        col_num = self.max_cols_fitted // 2
+        if col_num >= 1:
+            left = self.tr_frame.iloc[:, :col_num]
+            right = self.tr_frame.iloc[:, -col_num:]
+            self.tr_frame = concat((left, right), axis=1)
+
+            # truncate formatter
+            if isinstance(self.formatters, (list, tuple)):
+                self.formatters = [
+                    *self.formatters[:col_num],
+                    *self.formatters[-col_num:],
+                ]
+        else:
+            col_num = cast(int, self.max_cols)
+            self.tr_frame = self.tr_frame.iloc[:, :col_num]
+        self.tr_col_num = col_num
+
+    def _truncate_vertically(self) -> None:
+        """Remove rows, which are not to be displayed.
+
+        Attributes affected:
+            - tr_frame
+            - tr_row_num
+        """
+        assert self.max_rows_fitted is not None
+        row_num = self.max_rows_fitted // 2
+        if row_num >= 1:
+            _len = len(self.tr_frame)
+            _slice = np.hstack([np.arange(row_num), np.arange(_len - row_num, _len)])
+            self.tr_frame = self.tr_frame.iloc[_slice]
+        else:
+            row_num = cast(int, self.max_rows)
+            self.tr_frame = self.tr_frame.iloc[:row_num, :]
+        self.tr_row_num = row_num
+
+    def _get_strcols_without_index(self) -> list[list[str]]:
+        strcols: list[list[str]] = []
+
+        if not is_list_like(self.header) and not self.header:
+            for i, c in enumerate(self.tr_frame):
+                fmt_values = self.format_col(i)
+                fmt_values = _make_fixed_width(
+                    strings=fmt_values,
+                    justify=self.justify,
+                    minimum=int(self.col_space.get(c, 0)),
+                    adj=self.adj,
+                )
+                strcols.append(fmt_values)
+            return strcols
+
+        if is_list_like(self.header):
+            # cast here since can't be bool if is_list_like
+            self.header = cast(list[str], self.header)
+            if len(self.header) != len(self.columns):
+                raise ValueError(
+                    f"Writing {len(self.columns)} cols "
+                    f"but got {len(self.header)} aliases"
+                )
+            str_columns = [[label] for label in self.header]
+        else:
+            str_columns = self._get_formatted_column_labels(self.tr_frame)
+
+        if self.show_row_idx_names:
+            for x in str_columns:
+                x.append("")
+
+        for i, c in enumerate(self.tr_frame):
+            cheader = str_columns[i]
+            header_colwidth = max(
+                int(self.col_space.get(c, 0)), *(self.adj.len(x) for x in cheader)
+            )
+            fmt_values = self.format_col(i)
+            fmt_values = _make_fixed_width(
+                fmt_values, self.justify, minimum=header_colwidth, adj=self.adj
+            )
+
+            max_len = max(*(self.adj.len(x) for x in fmt_values), header_colwidth)
+            cheader = self.adj.justify(cheader, max_len, mode=self.justify)
+            strcols.append(cheader + fmt_values)
+
+        return strcols
+
+    def format_col(self, i: int) -> list[str]:
+        frame = self.tr_frame
+        formatter = self._get_formatter(i)
+        return format_array(
+            frame.iloc[:, i]._values,
+            formatter,
+            float_format=self.float_format,
+            na_rep=self.na_rep,
+            space=self.col_space.get(frame.columns[i]),
+            decimal=self.decimal,
+            leading_space=self.index,
+        )
+
+    def _get_formatter(self, i: str | int) -> Callable | None:
+        if isinstance(self.formatters, (list, tuple)):
+            if is_integer(i):
+                i = cast(int, i)
+                return self.formatters[i]
+            else:
+                return None
+        else:
+            if is_integer(i) and i not in self.columns:
+                i = self.columns[i]
+            return self.formatters.get(i, None)
+
+    def _get_formatted_column_labels(self, frame: DataFrame) -> list[list[str]]:
+        from pandas.core.indexes.multi import sparsify_labels
+
+        columns = frame.columns
+
+        if isinstance(columns, MultiIndex):
+            fmt_columns = columns._format_multi(sparsify=False, include_names=False)
+            fmt_columns = list(zip(*fmt_columns))
+            dtypes = self.frame.dtypes._values
+
+            # if we have a Float level, they don't use leading space at all
+            restrict_formatting = any(level.is_floating for level in columns.levels)
+            need_leadsp = dict(zip(fmt_columns, map(is_numeric_dtype, dtypes)))
+
+            def space_format(x, y):
+                if (
+                    y not in self.formatters
+                    and need_leadsp[x]
+                    and not restrict_formatting
+                ):
+                    return " " + y
+                return y
+
+            str_columns_tuple = list(
+                zip(*([space_format(x, y) for y in x] for x in fmt_columns))
+            )
+            if self.sparsify and len(str_columns_tuple):
+                str_columns_tuple = sparsify_labels(str_columns_tuple)
+
+            str_columns = [list(x) for x in zip(*str_columns_tuple)]
+        else:
+            fmt_columns = columns._format_flat(include_name=False)
+            dtypes = self.frame.dtypes
+            need_leadsp = dict(zip(fmt_columns, map(is_numeric_dtype, dtypes)))
+            str_columns = [
+                [" " + x if not self._get_formatter(i) and need_leadsp[x] else x]
+                for i, x in enumerate(fmt_columns)
+            ]
+        # self.str_columns = str_columns
+        return str_columns
+
+    def _get_formatted_index(self, frame: DataFrame) -> list[str]:
+        # Note: this is only used by to_string() and to_latex(), not by
+        # to_html(). so safe to cast col_space here.
+        col_space = {k: cast(int, v) for k, v in self.col_space.items()}
+        index = frame.index
+        columns = frame.columns
+        fmt = self._get_formatter("__index__")
+
+        if isinstance(index, MultiIndex):
+            fmt_index = index._format_multi(
+                sparsify=self.sparsify,
+                include_names=self.show_row_idx_names,
+                formatter=fmt,
+            )
+        else:
+            fmt_index = [
+                index._format_flat(include_name=self.show_row_idx_names, formatter=fmt)
+            ]
+
+        fmt_index = [
+            tuple(
+                _make_fixed_width(
+                    list(x), justify="left", minimum=col_space.get("", 0), adj=self.adj
+                )
+            )
+            for x in fmt_index
+        ]
+
+        adjoined = self.adj.adjoin(1, *fmt_index).split("\n")
+
+        # empty space for columns
+        if self.show_col_idx_names:
+            col_header = [str(x) for x in self._get_column_name_list()]
+        else:
+            col_header = [""] * columns.nlevels
+
+        if self.header:
+            return col_header + adjoined
+        else:
+            return adjoined
+
+    def _get_column_name_list(self) -> list[Hashable]:
+        names: list[Hashable] = []
+        columns = self.frame.columns
+        if isinstance(columns, MultiIndex):
+            names.extend("" if name is None else name for name in columns.names)
+        else:
+            names.append("" if columns.name is None else columns.name)
+        return names
+
+
+class DataFrameRenderer:
+    """Class for creating dataframe output in multiple formats.
+
+    Called in pandas.core.generic.NDFrame:
+        - to_csv
+        - to_latex
+
+    Called in pandas.core.frame.DataFrame:
+        - to_html
+        - to_string
+
+    Parameters
+    ----------
+    fmt : DataFrameFormatter
+        Formatter with the formatting options.
+    """
+
+    def __init__(self, fmt: DataFrameFormatter) -> None:
+        self.fmt = fmt
+
+    def to_html(
+        self,
+        buf: FilePath | WriteBuffer[str] | None = None,
+        encoding: str | None = None,
+        classes: str | list | tuple | None = None,
+        notebook: bool = False,
+        border: int | bool | None = None,
+        table_id: str | None = None,
+        render_links: bool = False,
+    ) -> str | None:
+        """
+        Render a DataFrame to a html table.
+
+        Parameters
+        ----------
+        buf : str, path object, file-like object, or None, default None
+            String, path object (implementing ``os.PathLike[str]``), or file-like
+            object implementing a string ``write()`` function. If None, the result is
+            returned as a string.
+        encoding : str, default “utf-8”
+            Set character encoding.
+        classes : str or list-like
+            classes to include in the `class` attribute of the opening
+            ``<table>`` tag, in addition to the default "dataframe".
+        notebook : {True, False}, optional, default False
+            Whether the generated HTML is for IPython Notebook.
+        border : int
+            A ``border=border`` attribute is included in the opening
+            ``<table>`` tag. Default ``pd.options.display.html.border``.
+        table_id : str, optional
+            A css id is included in the opening `<table>` tag if specified.
+        render_links : bool, default False
+            Convert URLs to HTML links.
+        """
+        from pandas.io.formats.html import (
+            HTMLFormatter,
+            NotebookFormatter,
+        )
+
+        Klass = NotebookFormatter if notebook else HTMLFormatter
+
+        html_formatter = Klass(
+            self.fmt,
+            classes=classes,
+            border=border,
+            table_id=table_id,
+            render_links=render_links,
+        )
+        string = html_formatter.to_string()
+        return save_to_buffer(string, buf=buf, encoding=encoding)
+
+    def to_string(
+        self,
+        buf: FilePath | WriteBuffer[str] | None = None,
+        encoding: str | None = None,
+        line_width: int | None = None,
+    ) -> str | None:
+        """
+        Render a DataFrame to a console-friendly tabular output.
+
+        Parameters
+        ----------
+        buf : str, path object, file-like object, or None, default None
+            String, path object (implementing ``os.PathLike[str]``), or file-like
+            object implementing a string ``write()`` function. If None, the result is
+            returned as a string.
+        encoding: str, default “utf-8”
+            Set character encoding.
+        line_width : int, optional
+            Width to wrap a line in characters.
+        """
+        from pandas.io.formats.string import StringFormatter
+
+        string_formatter = StringFormatter(self.fmt, line_width=line_width)
+        string = string_formatter.to_string()
+        return save_to_buffer(string, buf=buf, encoding=encoding)
+
+    def to_csv(
+        self,
+        path_or_buf: FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None = None,
+        encoding: str | None = None,
+        sep: str = ",",
+        columns: Sequence[Hashable] | None = None,
+        index_label: IndexLabel | None = None,
+        mode: str = "w",
+        compression: CompressionOptions = "infer",
+        quoting: int | None = None,
+        quotechar: str = '"',
+        lineterminator: str | None = None,
+        chunksize: int | None = None,
+        date_format: str | None = None,
+        doublequote: bool = True,
+        escapechar: str | None = None,
+        errors: str = "strict",
+        storage_options: StorageOptions | None = None,
+    ) -> str | None:
+        """
+        Render dataframe as comma-separated file.
+        """
+        from pandas.io.formats.csvs import CSVFormatter
+
+        if path_or_buf is None:
+            created_buffer = True
+            path_or_buf = StringIO()
+        else:
+            created_buffer = False
+
+        csv_formatter = CSVFormatter(
+            path_or_buf=path_or_buf,
+            lineterminator=lineterminator,
+            sep=sep,
+            encoding=encoding,
+            errors=errors,
+            compression=compression,
+            quoting=quoting,
+            cols=columns,
+            index_label=index_label,
+            mode=mode,
+            chunksize=chunksize,
+            quotechar=quotechar,
+            date_format=date_format,
+            doublequote=doublequote,
+            escapechar=escapechar,
+            storage_options=storage_options,
+            formatter=self.fmt,
+        )
+        csv_formatter.save()
+
+        if created_buffer:
+            assert isinstance(path_or_buf, StringIO)
+            content = path_or_buf.getvalue()
+            path_or_buf.close()
+            return content
+
+        return None
+
+
+def save_to_buffer(
+    string: str,
+    buf: FilePath | WriteBuffer[str] | None = None,
+    encoding: str | None = None,
+) -> str | None:
+    """
+    Perform serialization. Write to buf or return as string if buf is None.
+    """
+    with _get_buffer(buf, encoding=encoding) as fd:
+        fd.write(string)
+        if buf is None:
+            # error: "WriteBuffer[str]" has no attribute "getvalue"
+            return fd.getvalue()  # type: ignore[attr-defined]
+        return None
+
+
+@contextmanager
+def _get_buffer(
+    buf: FilePath | WriteBuffer[str] | None, encoding: str | None = None
+) -> Generator[WriteBuffer[str], None, None] | Generator[StringIO, None, None]:
+    """
+    Context manager to open, yield and close buffer for filenames or Path-like
+    objects, otherwise yield buf unchanged.
+    """
+    if buf is not None:
+        buf = stringify_path(buf)
+    else:
+        buf = StringIO()
+
+    if encoding is None:
+        encoding = "utf-8"
+    elif not isinstance(buf, str):
+        raise ValueError("buf is not a file name and encoding is specified.")
+
+    if hasattr(buf, "write"):
+        # Incompatible types in "yield" (actual type "Union[str, WriteBuffer[str],
+        # StringIO]", expected type "Union[WriteBuffer[str], StringIO]")
+        yield buf  # type: ignore[misc]
+    elif isinstance(buf, str):
+        check_parent_directory(str(buf))
+        with open(buf, "w", encoding=encoding, newline="") as f:
+            # GH#30034 open instead of codecs.open prevents a file leak
+            #  if we have an invalid encoding argument.
+            # newline="" is needed to roundtrip correctly on
+            #  windows test_to_latex_filename
+            yield f
+    else:
+        raise TypeError("buf is not a file name and it has no write method")
+
+
+# ----------------------------------------------------------------------
+# Array formatters
+
+
+def format_array(
+    values: ArrayLike,
+    formatter: Callable | None,
+    float_format: FloatFormatType | None = None,
+    na_rep: str = "NaN",
+    digits: int | None = None,
+    space: str | int | None = None,
+    justify: str = "right",
+    decimal: str = ".",
+    leading_space: bool | None = True,
+    quoting: int | None = None,
+    fallback_formatter: Callable | None = None,
+) -> list[str]:
+    """
+    Format an array for printing.
+
+    Parameters
+    ----------
+    values : np.ndarray or ExtensionArray
+    formatter
+    float_format
+    na_rep
+    digits
+    space
+    justify
+    decimal
+    leading_space : bool, optional, default True
+        Whether the array should be formatted with a leading space.
+        When an array as a column of a Series or DataFrame, we do want
+        the leading space to pad between columns.
+
+        When formatting an Index subclass
+        (e.g. IntervalIndex._get_values_for_csv), we don't want the
+        leading space since it should be left-aligned.
+    fallback_formatter
+
+    Returns
+    -------
+    List[str]
+    """
+    fmt_klass: type[_GenericArrayFormatter]
+    if lib.is_np_dtype(values.dtype, "M"):
+        fmt_klass = _Datetime64Formatter
+        values = cast(DatetimeArray, values)
+    elif isinstance(values.dtype, DatetimeTZDtype):
+        fmt_klass = _Datetime64TZFormatter
+        values = cast(DatetimeArray, values)
+    elif lib.is_np_dtype(values.dtype, "m"):
+        fmt_klass = _Timedelta64Formatter
+        values = cast(TimedeltaArray, values)
+    elif isinstance(values.dtype, ExtensionDtype):
+        fmt_klass = _ExtensionArrayFormatter
+    elif lib.is_np_dtype(values.dtype, "fc"):
+        fmt_klass = FloatArrayFormatter
+    elif lib.is_np_dtype(values.dtype, "iu"):
+        fmt_klass = _IntArrayFormatter
+    else:
+        fmt_klass = _GenericArrayFormatter
+
+    if space is None:
+        space = 12
+
+    if float_format is None:
+        float_format = get_option("display.float_format")
+
+    if digits is None:
+        digits = get_option("display.precision")
+
+    fmt_obj = fmt_klass(
+        values,
+        digits=digits,
+        na_rep=na_rep,
+        float_format=float_format,
+        formatter=formatter,
+        space=space,
+        justify=justify,
+        decimal=decimal,
+        leading_space=leading_space,
+        quoting=quoting,
+        fallback_formatter=fallback_formatter,
+    )
+
+    return fmt_obj.get_result()
+
+
+class _GenericArrayFormatter:
+    def __init__(
+        self,
+        values: ArrayLike,
+        digits: int = 7,
+        formatter: Callable | None = None,
+        na_rep: str = "NaN",
+        space: str | int = 12,
+        float_format: FloatFormatType | None = None,
+        justify: str = "right",
+        decimal: str = ".",
+        quoting: int | None = None,
+        fixed_width: bool = True,
+        leading_space: bool | None = True,
+        fallback_formatter: Callable | None = None,
+    ) -> None:
+        self.values = values
+        self.digits = digits
+        self.na_rep = na_rep
+        self.space = space
+        self.formatter = formatter
+        self.float_format = float_format
+        self.justify = justify
+        self.decimal = decimal
+        self.quoting = quoting
+        self.fixed_width = fixed_width
+        self.leading_space = leading_space
+        self.fallback_formatter = fallback_formatter
+
+    def get_result(self) -> list[str]:
+        fmt_values = self._format_strings()
+        return _make_fixed_width(fmt_values, self.justify)
+
+    def _format_strings(self) -> list[str]:
+        if self.float_format is None:
+            float_format = get_option("display.float_format")
+            if float_format is None:
+                precision = get_option("display.precision")
+                float_format = lambda x: _trim_zeros_single_float(
+                    f"{x: .{precision:d}f}"
+                )
+        else:
+            float_format = self.float_format
+
+        if self.formatter is not None:
+            formatter = self.formatter
+        elif self.fallback_formatter is not None:
+            formatter = self.fallback_formatter
+        else:
+            quote_strings = self.quoting is not None and self.quoting != QUOTE_NONE
+            formatter = partial(
+                printing.pprint_thing,
+                escape_chars=("\t", "\r", "\n"),
+                quote_strings=quote_strings,
+            )
+
+        def _format(x):
+            if self.na_rep is not None and is_scalar(x) and isna(x):
+                if x is None:
+                    return "None"
+                elif x is NA:
+                    return str(NA)
+                elif lib.is_float(x) and np.isinf(x):
+                    # TODO(3.0): this will be unreachable when use_inf_as_na
+                    #  deprecation is enforced
+                    return str(x)
+                elif x is NaT or isinstance(x, (np.datetime64, np.timedelta64)):
+                    return "NaT"
+                return self.na_rep
+            elif isinstance(x, PandasObject):
+                return str(x)
+            elif isinstance(x, StringDtype):
+                return repr(x)
+            else:
+                # object dtype
+                return str(formatter(x))
+
+        vals = self.values
+        if not isinstance(vals, np.ndarray):
+            raise TypeError(
+                "ExtensionArray formatting should use _ExtensionArrayFormatter"
+            )
+        inferred = lib.map_infer(vals, is_float)
+        is_float_type = (
+            inferred
+            # vals may have 2 or more dimensions
+            & np.all(notna(vals), axis=tuple(range(1, len(vals.shape))))
+        )
+        leading_space = self.leading_space
+        if leading_space is None:
+            leading_space = is_float_type.any()
+
+        fmt_values = []
+        for i, v in enumerate(vals):
+            if (not is_float_type[i] or self.formatter is not None) and leading_space:
+                fmt_values.append(f" {_format(v)}")
+            elif is_float_type[i]:
+                fmt_values.append(float_format(v))
+            else:
+                if leading_space is False:
+                    # False specifically, so that the default is
+                    # to include a space if we get here.
+                    tpl = "{v}"
+                else:
+                    tpl = " {v}"
+                fmt_values.append(tpl.format(v=_format(v)))
+
+        return fmt_values
+
+
+class FloatArrayFormatter(_GenericArrayFormatter):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        # float_format is expected to be a string
+        # formatter should be used to pass a function
+        if self.float_format is not None and self.formatter is None:
+            # GH21625, GH22270
+            self.fixed_width = False
+            if callable(self.float_format):
+                self.formatter = self.float_format
+                self.float_format = None
+
+    def _value_formatter(
+        self,
+        float_format: FloatFormatType | None = None,
+        threshold: float | None = None,
+    ) -> Callable:
+        """Returns a function to be applied on each value to format it"""
+        # the float_format parameter supersedes self.float_format
+        if float_format is None:
+            float_format = self.float_format
+
+        # we are going to compose different functions, to first convert to
+        # a string, then replace the decimal symbol, and finally chop according
+        # to the threshold
+
+        # when there is no float_format, we use str instead of '%g'
+        # because str(0.0) = '0.0' while '%g' % 0.0 = '0'
+        if float_format:
+
+            def base_formatter(v):
+                assert float_format is not None  # for mypy
+                # error: "str" not callable
+                # error: Unexpected keyword argument "value" for "__call__" of
+                # "EngFormatter"
+                return (
+                    float_format(value=v)  # type: ignore[operator,call-arg]
+                    if notna(v)
+                    else self.na_rep
+                )
+
+        else:
+
+            def base_formatter(v):
+                return str(v) if notna(v) else self.na_rep
+
+        if self.decimal != ".":
+
+            def decimal_formatter(v):
+                return base_formatter(v).replace(".", self.decimal, 1)
+
+        else:
+            decimal_formatter = base_formatter
+
+        if threshold is None:
+            return decimal_formatter
+
+        def formatter(value):
+            if notna(value):
+                if abs(value) > threshold:
+                    return decimal_formatter(value)
+                else:
+                    return decimal_formatter(0.0)
+            else:
+                return self.na_rep
+
+        return formatter
+
+    def get_result_as_array(self) -> np.ndarray:
+        """
+        Returns the float values converted into strings using
+        the parameters given at initialisation, as a numpy array
+        """
+
+        def format_with_na_rep(values: ArrayLike, formatter: Callable, na_rep: str):
+            mask = isna(values)
+            formatted = np.array(
+                [
+                    formatter(val) if not m else na_rep
+                    for val, m in zip(values.ravel(), mask.ravel())
+                ]
+            ).reshape(values.shape)
+            return formatted
+
+        def format_complex_with_na_rep(
+            values: ArrayLike, formatter: Callable, na_rep: str
+        ):
+            real_values = np.real(values).ravel()  # type: ignore[arg-type]
+            imag_values = np.imag(values).ravel()  # type: ignore[arg-type]
+            real_mask, imag_mask = isna(real_values), isna(imag_values)
+            formatted_lst = []
+            for val, real_val, imag_val, re_isna, im_isna in zip(
+                values.ravel(),
+                real_values,
+                imag_values,
+                real_mask,
+                imag_mask,
+            ):
+                if not re_isna and not im_isna:
+                    formatted_lst.append(formatter(val))
+                elif not re_isna:  # xxx+nanj
+                    formatted_lst.append(f"{formatter(real_val)}+{na_rep}j")
+                elif not im_isna:  # nan[+/-]xxxj
+                    # The imaginary part may either start with a "-" or a space
+                    imag_formatted = formatter(imag_val).strip()
+                    if imag_formatted.startswith("-"):
+                        formatted_lst.append(f"{na_rep}{imag_formatted}j")
+                    else:
+                        formatted_lst.append(f"{na_rep}+{imag_formatted}j")
+                else:  # nan+nanj
+                    formatted_lst.append(f"{na_rep}+{na_rep}j")
+            return np.array(formatted_lst).reshape(values.shape)
+
+        if self.formatter is not None:
+            return format_with_na_rep(self.values, self.formatter, self.na_rep)
+
+        if self.fixed_width:
+            threshold = get_option("display.chop_threshold")
+        else:
+            threshold = None
+
+        # if we have a fixed_width, we'll need to try different float_format
+        def format_values_with(float_format):
+            formatter = self._value_formatter(float_format, threshold)
+
+            # default formatter leaves a space to the left when formatting
+            # floats, must be consistent for left-justifying NaNs (GH #25061)
+            na_rep = " " + self.na_rep if self.justify == "left" else self.na_rep
+
+            # different formatting strategies for complex and non-complex data
+            # need to distinguish complex and float NaNs (GH #53762)
+            values = self.values
+            is_complex = is_complex_dtype(values)
+
+            # separate the wheat from the chaff
+            if is_complex:
+                values = format_complex_with_na_rep(values, formatter, na_rep)
+            else:
+                values = format_with_na_rep(values, formatter, na_rep)
+
+            if self.fixed_width:
+                if is_complex:
+                    result = _trim_zeros_complex(values, self.decimal)
+                else:
+                    result = _trim_zeros_float(values, self.decimal)
+                return np.asarray(result, dtype="object")
+
+            return values
+
+        # There is a special default string when we are fixed-width
+        # The default is otherwise to use str instead of a formatting string
+        float_format: FloatFormatType | None
+        if self.float_format is None:
+            if self.fixed_width:
+                if self.leading_space is True:
+                    fmt_str = "{value: .{digits:d}f}"
+                else:
+                    fmt_str = "{value:.{digits:d}f}"
+                float_format = partial(fmt_str.format, digits=self.digits)
+            else:
+                float_format = self.float_format
+        else:
+            float_format = lambda value: self.float_format % value
+
+        formatted_values = format_values_with(float_format)
+
+        if not self.fixed_width:
+            return formatted_values
+
+        # we need do convert to engineering format if some values are too small
+        # and would appear as 0, or if some values are too big and take too
+        # much space
+
+        if len(formatted_values) > 0:
+            maxlen = max(len(x) for x in formatted_values)
+            too_long = maxlen > self.digits + 6
+        else:
+            too_long = False
+
+        abs_vals = np.abs(self.values)
+        # this is pretty arbitrary for now
+        # large values: more that 8 characters including decimal symbol
+        # and first digit, hence > 1e6
+        has_large_values = (abs_vals > 1e6).any()
+        has_small_values = ((abs_vals < 10 ** (-self.digits)) & (abs_vals > 0)).any()
+
+        if has_small_values or (too_long and has_large_values):
+            if self.leading_space is True:
+                fmt_str = "{value: .{digits:d}e}"
+            else:
+                fmt_str = "{value:.{digits:d}e}"
+            float_format = partial(fmt_str.format, digits=self.digits)
+            formatted_values = format_values_with(float_format)
+
+        return formatted_values
+
+    def _format_strings(self) -> list[str]:
+        return list(self.get_result_as_array())
+
+
+class _IntArrayFormatter(_GenericArrayFormatter):
+    def _format_strings(self) -> list[str]:
+        if self.leading_space is False:
+            formatter_str = lambda x: f"{x:d}".format(x=x)
+        else:
+            formatter_str = lambda x: f"{x: d}".format(x=x)
+        formatter = self.formatter or formatter_str
+        fmt_values = [formatter(x) for x in self.values]
+        return fmt_values
+
+
+class _Datetime64Formatter(_GenericArrayFormatter):
+    values: DatetimeArray
+
+    def __init__(
+        self,
+        values: DatetimeArray,
+        nat_rep: str = "NaT",
+        date_format: None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(values, **kwargs)
+        self.nat_rep = nat_rep
+        self.date_format = date_format
+
+    def _format_strings(self) -> list[str]:
+        """we by definition have DO NOT have a TZ"""
+        values = self.values
+
+        if self.formatter is not None:
+            return [self.formatter(x) for x in values]
+
+        fmt_values = values._format_native_types(
+            na_rep=self.nat_rep, date_format=self.date_format
+        )
+        return fmt_values.tolist()
+
+
+class _ExtensionArrayFormatter(_GenericArrayFormatter):
+    values: ExtensionArray
+
+    def _format_strings(self) -> list[str]:
+        values = self.values
+
+        formatter = self.formatter
+        fallback_formatter = None
+        if formatter is None:
+            fallback_formatter = values._formatter(boxed=True)
+
+        if isinstance(values, Categorical):
+            # Categorical is special for now, so that we can preserve tzinfo
+            array = values._internal_get_values()
+        else:
+            array = np.asarray(values, dtype=object)
+
+        fmt_values = format_array(
+            array,
+            formatter,
+            float_format=self.float_format,
+            na_rep=self.na_rep,
+            digits=self.digits,
+            space=self.space,
+            justify=self.justify,
+            decimal=self.decimal,
+            leading_space=self.leading_space,
+            quoting=self.quoting,
+            fallback_formatter=fallback_formatter,
+        )
+        return fmt_values
+
+
+def format_percentiles(
+    percentiles: (np.ndarray | Sequence[float]),
+) -> list[str]:
+    """
+    Outputs rounded and formatted percentiles.
+
+    Parameters
+    ----------
+    percentiles : list-like, containing floats from interval [0,1]
+
+    Returns
+    -------
+    formatted : list of strings
+
+    Notes
+    -----
+    Rounding precision is chosen so that: (1) if any two elements of
+    ``percentiles`` differ, they remain different after rounding
+    (2) no entry is *rounded* to 0% or 100%.
+    Any non-integer is always rounded to at least 1 decimal place.
+
+    Examples
+    --------
+    Keeps all entries different after rounding:
+
+    >>> format_percentiles([0.01999, 0.02001, 0.5, 0.666666, 0.9999])
+    ['1.999%', '2.001%', '50%', '66.667%', '99.99%']
+
+    No element is rounded to 0% or 100% (unless already equal to it).
+    Duplicates are allowed:
+
+    >>> format_percentiles([0, 0.5, 0.02001, 0.5, 0.666666, 0.9999])
+    ['0%', '50%', '2.0%', '50%', '66.67%', '99.99%']
+    """
+    percentiles = np.asarray(percentiles)
+
+    # It checks for np.nan as well
+    if (
+        not is_numeric_dtype(percentiles)
+        or not np.all(percentiles >= 0)
+        or not np.all(percentiles <= 1)
+    ):
+        raise ValueError("percentiles should all be in the interval [0,1]")
+
+    percentiles = 100 * percentiles
+    prec = get_precision(percentiles)
+    percentiles_round_type = percentiles.round(prec).astype(int)
+
+    int_idx = np.isclose(percentiles_round_type, percentiles)
+
+    if np.all(int_idx):
+        out = percentiles_round_type.astype(str)
+        return [i + "%" for i in out]
+
+    unique_pcts = np.unique(percentiles)
+    prec = get_precision(unique_pcts)
+    out = np.empty_like(percentiles, dtype=object)
+    out[int_idx] = percentiles[int_idx].round().astype(int).astype(str)
+
+    out[~int_idx] = percentiles[~int_idx].round(prec).astype(str)
+    return [i + "%" for i in out]
+
+
+def get_precision(array: np.ndarray | Sequence[float]) -> int:
+    to_begin = array[0] if array[0] > 0 else None
+    to_end = 100 - array[-1] if array[-1] < 100 else None
+    diff = np.ediff1d(array, to_begin=to_begin, to_end=to_end)
+    diff = abs(diff)
+    prec = -np.floor(np.log10(np.min(diff))).astype(int)
+    prec = max(1, prec)
+    return prec
+
+
+def _format_datetime64(x: NaTType | Timestamp, nat_rep: str = "NaT") -> str:
+    if x is NaT:
+        return nat_rep
+
+    # Timestamp.__str__ falls back to datetime.datetime.__str__ = isoformat(sep=' ')
+    # so it already uses string formatting rather than strftime (faster).
+    return str(x)
+
+
+def _format_datetime64_dateonly(
+    x: NaTType | Timestamp,
+    nat_rep: str = "NaT",
+    date_format: str | None = None,
+) -> str:
+    if isinstance(x, NaTType):
+        return nat_rep
+
+    if date_format:
+        return x.strftime(date_format)
+    else:
+        # Timestamp._date_repr relies on string formatting (faster than strftime)
+        return x._date_repr
+
+
+def get_format_datetime64(
+    is_dates_only: bool, nat_rep: str = "NaT", date_format: str | None = None
+) -> Callable:
+    """Return a formatter callable taking a datetime64 as input and providing
+    a string as output"""
+
+    if is_dates_only:
+        return lambda x: _format_datetime64_dateonly(
+            x, nat_rep=nat_rep, date_format=date_format
+        )
+    else:
+        return lambda x: _format_datetime64(x, nat_rep=nat_rep)
+
+
+class _Datetime64TZFormatter(_Datetime64Formatter):
+    values: DatetimeArray
+
+    def _format_strings(self) -> list[str]:
+        """we by definition have a TZ"""
+        ido = self.values._is_dates_only
+        values = self.values.astype(object)
+        formatter = self.formatter or get_format_datetime64(
+            ido, date_format=self.date_format
+        )
+        fmt_values = [formatter(x) for x in values]
+
+        return fmt_values
+
+
+class _Timedelta64Formatter(_GenericArrayFormatter):
+    values: TimedeltaArray
+
+    def __init__(
+        self,
+        values: TimedeltaArray,
+        nat_rep: str = "NaT",
+        **kwargs,
+    ) -> None:
+        # TODO: nat_rep is never passed, na_rep is.
+        super().__init__(values, **kwargs)
+        self.nat_rep = nat_rep
+
+    def _format_strings(self) -> list[str]:
+        formatter = self.formatter or get_format_timedelta64(
+            self.values, nat_rep=self.nat_rep, box=False
+        )
+        return [formatter(x) for x in self.values]
+
+
+def get_format_timedelta64(
+    values: TimedeltaArray,
+    nat_rep: str | float = "NaT",
+    box: bool = False,
+) -> Callable:
+    """
+    Return a formatter function for a range of timedeltas.
+    These will all have the same format argument
+
+    If box, then show the return in quotes
+    """
+    even_days = values._is_dates_only
+
+    if even_days:
+        format = None
+    else:
+        format = "long"
+
+    def _formatter(x):
+        if x is None or (is_scalar(x) and isna(x)):
+            return nat_rep
+
+        if not isinstance(x, Timedelta):
+            x = Timedelta(x)
+
+        # Timedelta._repr_base uses string formatting (faster than strftime)
+        result = x._repr_base(format=format)
+        if box:
+            result = f"'{result}'"
+        return result
+
+    return _formatter
+
+
+def _make_fixed_width(
+    strings: list[str],
+    justify: str = "right",
+    minimum: int | None = None,
+    adj: printing._TextAdjustment | None = None,
+) -> list[str]:
+    if len(strings) == 0 or justify == "all":
+        return strings
+
+    if adj is None:
+        adjustment = printing.get_adjustment()
+    else:
+        adjustment = adj
+
+    max_len = max(adjustment.len(x) for x in strings)
+
+    if minimum is not None:
+        max_len = max(minimum, max_len)
+
+    conf_max = get_option("display.max_colwidth")
+    if conf_max is not None and max_len > conf_max:
+        max_len = conf_max
+
+    def just(x: str) -> str:
+        if conf_max is not None:
+            if (conf_max > 3) & (adjustment.len(x) > max_len):
+                x = x[: max_len - 3] + "..."
+        return x
+
+    strings = [just(x) for x in strings]
+    result = adjustment.justify(strings, max_len, mode=justify)
+    return result
+
+
+def _trim_zeros_complex(str_complexes: ArrayLike, decimal: str = ".") -> list[str]:
+    """
+    Separates the real and imaginary parts from the complex number, and
+    executes the _trim_zeros_float method on each of those.
+    """
+    real_part, imag_part = [], []
+    for x in str_complexes:
+        # Complex numbers are represented as "(-)xxx(+/-)xxxj"
+        # The split will give [{"", "-"}, "xxx", "+/-", "xxx", "j", ""]
+        # Therefore, the imaginary part is the 4th and 3rd last elements,
+        # and the real part is everything before the imaginary part
+        trimmed = re.split(r"([j+-])", x)
+        real_part.append("".join(trimmed[:-4]))
+        imag_part.append("".join(trimmed[-4:-2]))
+
+    # We want to align the lengths of the real and imaginary parts of each complex
+    # number, as well as the lengths the real (resp. complex) parts of all numbers
+    # in the array
+    n = len(str_complexes)
+    padded_parts = _trim_zeros_float(real_part + imag_part, decimal)
+    if len(padded_parts) == 0:
+        return []
+    padded_length = max(len(part) for part in padded_parts) - 1
+    padded = [
+        real_pt  # real part, possibly NaN
+        + imag_pt[0]  # +/-
+        + f"{imag_pt[1:]:>{padded_length}}"  # complex part (no sign), possibly nan
+        + "j"
+        for real_pt, imag_pt in zip(padded_parts[:n], padded_parts[n:])
+    ]
+    return padded
+
+
+def _trim_zeros_single_float(str_float: str) -> str:
+    """
+    Trims trailing zeros after a decimal point,
+    leaving just one if necessary.
+    """
+    str_float = str_float.rstrip("0")
+    if str_float.endswith("."):
+        str_float += "0"
+
+    return str_float
+
+
+def _trim_zeros_float(
+    str_floats: ArrayLike | list[str], decimal: str = "."
+) -> list[str]:
+    """
+    Trims the maximum number of trailing zeros equally from
+    all numbers containing decimals, leaving just one if
+    necessary.
+    """
+    trimmed = str_floats
+    number_regex = re.compile(rf"^\s*[\+-]?[0-9]+\{decimal}[0-9]*$")
+
+    def is_number_with_decimal(x) -> bool:
+        return re.match(number_regex, x) is not None
+
+    def should_trim(values: ArrayLike | list[str]) -> bool:
+        """
+        Determine if an array of strings should be trimmed.
+
+        Returns True if all numbers containing decimals (defined by the
+        above regular expression) within the array end in a zero, otherwise
+        returns False.
+        """
+        numbers = [x for x in values if is_number_with_decimal(x)]
+        return len(numbers) > 0 and all(x.endswith("0") for x in numbers)
+
+    while should_trim(trimmed):
+        trimmed = [x[:-1] if is_number_with_decimal(x) else x for x in trimmed]
+
+    # leave one 0 after the decimal points if need be.
+    result = [
+        x + "0" if is_number_with_decimal(x) and x.endswith(decimal) else x
+        for x in trimmed
+    ]
+    return result
+
+
+def _has_names(index: Index) -> bool:
+    if isinstance(index, MultiIndex):
+        return com.any_not_none(*index.names)
+    else:
+        return index.name is not None
+
+
+class EngFormatter:
+    """
+    Formats float values according to engineering format.
+
+    Based on matplotlib.ticker.EngFormatter
+    """
+
+    # The SI engineering prefixes
+    ENG_PREFIXES = {
+        -24: "y",
+        -21: "z",
+        -18: "a",
+        -15: "f",
+        -12: "p",
+        -9: "n",
+        -6: "u",
+        -3: "m",
+        0: "",
+        3: "k",
+        6: "M",
+        9: "G",
+        12: "T",
+        15: "P",
+        18: "E",
+        21: "Z",
+        24: "Y",
+    }
+
+    def __init__(
+        self, accuracy: int | None = None, use_eng_prefix: bool = False
+    ) -> None:
+        self.accuracy = accuracy
+        self.use_eng_prefix = use_eng_prefix
+
+    def __call__(self, num: float) -> str:
+        """
+        Formats a number in engineering notation, appending a letter
+        representing the power of 1000 of the original number. Some examples:
+        >>> format_eng = EngFormatter(accuracy=0, use_eng_prefix=True)
+        >>> format_eng(0)
+        ' 0'
+        >>> format_eng = EngFormatter(accuracy=1, use_eng_prefix=True)
+        >>> format_eng(1_000_000)
+        ' 1.0M'
+        >>> format_eng = EngFormatter(accuracy=2, use_eng_prefix=False)
+        >>> format_eng("-1e-6")
+        '-1.00E-06'
+
+        @param num: the value to represent
+        @type num: either a numeric value or a string that can be converted to
+                   a numeric value (as per decimal.Decimal constructor)
+
+        @return: engineering formatted string
+        """
+        dnum = Decimal(str(num))
+
+        if Decimal.is_nan(dnum):
+            return "NaN"
+
+        if Decimal.is_infinite(dnum):
+            return "inf"
+
+        sign = 1
+
+        if dnum < 0:  # pragma: no cover
+            sign = -1
+            dnum = -dnum
+
+        if dnum != 0:
+            pow10 = Decimal(int(math.floor(dnum.log10() / 3) * 3))
+        else:
+            pow10 = Decimal(0)
+
+        pow10 = pow10.min(max(self.ENG_PREFIXES.keys()))
+        pow10 = pow10.max(min(self.ENG_PREFIXES.keys()))
+        int_pow10 = int(pow10)
+
+        if self.use_eng_prefix:
+            prefix = self.ENG_PREFIXES[int_pow10]
+        elif int_pow10 < 0:
+            prefix = f"E-{-int_pow10:02d}"
+        else:
+            prefix = f"E+{int_pow10:02d}"
+
+        mant = sign * dnum / (10**pow10)
+
+        if self.accuracy is None:  # pragma: no cover
+            format_str = "{mant: g}{prefix}"
+        else:
+            format_str = f"{{mant: .{self.accuracy:d}f}}{{prefix}}"
+
+        formatted = format_str.format(mant=mant, prefix=prefix)
+
+        return formatted
+
+
+def set_eng_float_format(accuracy: int = 3, use_eng_prefix: bool = False) -> None:
+    """
+    Format float representation in DataFrame with SI notation.
+
+    Parameters
+    ----------
+    accuracy : int, default 3
+        Number of decimal digits after the floating point.
+    use_eng_prefix : bool, default False
+        Whether to represent a value with SI prefixes.
+
+    Returns
+    -------
+    None
+
+    Examples
+    --------
+    >>> df = pd.DataFrame([1e-9, 1e-3, 1, 1e3, 1e6])
+    >>> df
+                  0
+    0  1.000000e-09
+    1  1.000000e-03
+    2  1.000000e+00
+    3  1.000000e+03
+    4  1.000000e+06
+
+    >>> pd.set_eng_float_format(accuracy=1)
+    >>> df
+             0
+    0  1.0E-09
+    1  1.0E-03
+    2  1.0E+00
+    3  1.0E+03
+    4  1.0E+06
+
+    >>> pd.set_eng_float_format(use_eng_prefix=True)
+    >>> df
+            0
+    0  1.000n
+    1  1.000m
+    2   1.000
+    3  1.000k
+    4  1.000M
+
+    >>> pd.set_eng_float_format(accuracy=1, use_eng_prefix=True)
+    >>> df
+          0
+    0  1.0n
+    1  1.0m
+    2   1.0
+    3  1.0k
+    4  1.0M
+
+    >>> pd.set_option("display.float_format", None)  # unset option
+    """
+    set_option("display.float_format", EngFormatter(accuracy, use_eng_prefix))
+
+
+def get_level_lengths(
+    levels: Any, sentinel: bool | object | str = ""
+) -> list[dict[int, int]]:
+    """
+    For each index in each level the function returns lengths of indexes.
+
+    Parameters
+    ----------
+    levels : list of lists
+        List of values on for level.
+    sentinel : string, optional
+        Value which states that no new index starts on there.
+
+    Returns
+    -------
+    Returns list of maps. For each level returns map of indexes (key is index
+    in row and value is length of index).
+    """
+    if len(levels) == 0:
+        return []
+
+    control = [True] * len(levels[0])
+
+    result = []
+    for level in levels:
+        last_index = 0
+
+        lengths = {}
+        for i, key in enumerate(level):
+            if control[i] and key == sentinel:
+                pass
+            else:
+                control[i] = False
+                lengths[last_index] = i - last_index
+                last_index = i
+
+        lengths[last_index] = len(level) - last_index
+
+        result.append(lengths)
+
+    return result
+
+
+def buffer_put_lines(buf: WriteBuffer[str], lines: list[str]) -> None:
+    """
+    Appends lines to a buffer.
+
+    Parameters
+    ----------
+    buf
+        The buffer to write to
+    lines
+        The lines to append.
+    """
+    if any(isinstance(x, str) for x in lines):
+        lines = [str(x) for x in lines]
+    buf.write("\n".join(lines))

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

@@ -0,0 +1,646 @@
+"""
+Module for formatting output data in HTML.
+"""
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Final,
+    cast,
+)
+
+from pandas._config import get_option
+
+from pandas._libs import lib
+
+from pandas import (
+    MultiIndex,
+    option_context,
+)
+
+from pandas.io.common import is_url
+from pandas.io.formats.format import (
+    DataFrameFormatter,
+    get_level_lengths,
+)
+from pandas.io.formats.printing import pprint_thing
+
+if TYPE_CHECKING:
+    from collections.abc import (
+        Hashable,
+        Iterable,
+        Mapping,
+    )
+
+
+class HTMLFormatter:
+    """
+    Internal class for formatting output data in html.
+    This class is intended for shared functionality between
+    DataFrame.to_html() and DataFrame._repr_html_().
+    Any logic in common with other output formatting methods
+    should ideally be inherited from classes in format.py
+    and this class responsible for only producing html markup.
+    """
+
+    indent_delta: Final = 2
+
+    def __init__(
+        self,
+        formatter: DataFrameFormatter,
+        classes: str | list[str] | tuple[str, ...] | None = None,
+        border: int | bool | None = None,
+        table_id: str | None = None,
+        render_links: bool = False,
+    ) -> None:
+        self.fmt = formatter
+        self.classes = classes
+
+        self.frame = self.fmt.frame
+        self.columns = self.fmt.tr_frame.columns
+        self.elements: list[str] = []
+        self.bold_rows = self.fmt.bold_rows
+        self.escape = self.fmt.escape
+        self.show_dimensions = self.fmt.show_dimensions
+        if border is None or border is True:
+            border = cast(int, get_option("display.html.border"))
+        elif not border:
+            border = None
+
+        self.border = border
+        self.table_id = table_id
+        self.render_links = render_links
+
+        self.col_space = {}
+        is_multi_index = isinstance(self.columns, MultiIndex)
+        for column, value in self.fmt.col_space.items():
+            col_space_value = f"{value}px" if isinstance(value, int) else value
+            self.col_space[column] = col_space_value
+            # GH 53885: Handling case where column is index
+            # Flatten the data in the multi index and add in the map
+            if is_multi_index and isinstance(column, tuple):
+                for column_index in column:
+                    self.col_space[str(column_index)] = col_space_value
+
+    def to_string(self) -> str:
+        lines = self.render()
+        if any(isinstance(x, str) for x in lines):
+            lines = [str(x) for x in lines]
+        return "\n".join(lines)
+
+    def render(self) -> list[str]:
+        self._write_table()
+
+        if self.should_show_dimensions:
+            by = chr(215)  # ×  # noqa: RUF003
+            self.write(
+                f"<p>{len(self.frame)} rows {by} {len(self.frame.columns)} columns</p>"
+            )
+
+        return self.elements
+
+    @property
+    def should_show_dimensions(self) -> bool:
+        return self.fmt.should_show_dimensions
+
+    @property
+    def show_row_idx_names(self) -> bool:
+        return self.fmt.show_row_idx_names
+
+    @property
+    def show_col_idx_names(self) -> bool:
+        return self.fmt.show_col_idx_names
+
+    @property
+    def row_levels(self) -> int:
+        if self.fmt.index:
+            # showing (row) index
+            return self.frame.index.nlevels
+        elif self.show_col_idx_names:
+            # see gh-22579
+            # Column misalignment also occurs for
+            # a standard index when the columns index is named.
+            # If the row index is not displayed a column of
+            # blank cells need to be included before the DataFrame values.
+            return 1
+        # not showing (row) index
+        return 0
+
+    def _get_columns_formatted_values(self) -> Iterable:
+        return self.columns
+
+    @property
+    def is_truncated(self) -> bool:
+        return self.fmt.is_truncated
+
+    @property
+    def ncols(self) -> int:
+        return len(self.fmt.tr_frame.columns)
+
+    def write(self, s: Any, indent: int = 0) -> None:
+        rs = pprint_thing(s)
+        self.elements.append(" " * indent + rs)
+
+    def write_th(
+        self, s: Any, header: bool = False, indent: int = 0, tags: str | None = None
+    ) -> None:
+        """
+        Method for writing a formatted <th> cell.
+
+        If col_space is set on the formatter then that is used for
+        the value of min-width.
+
+        Parameters
+        ----------
+        s : object
+            The data to be written inside the cell.
+        header : bool, default False
+            Set to True if the <th> is for use inside <thead>.  This will
+            cause min-width to be set if there is one.
+        indent : int, default 0
+            The indentation level of the cell.
+        tags : str, default None
+            Tags to include in the cell.
+
+        Returns
+        -------
+        A written <th> cell.
+        """
+        col_space = self.col_space.get(s, None)
+
+        if header and col_space is not None:
+            tags = tags or ""
+            tags += f'style="min-width: {col_space};"'
+
+        self._write_cell(s, kind="th", indent=indent, tags=tags)
+
+    def write_td(self, s: Any, indent: int = 0, tags: str | None = None) -> None:
+        self._write_cell(s, kind="td", indent=indent, tags=tags)
+
+    def _write_cell(
+        self, s: Any, kind: str = "td", indent: int = 0, tags: str | None = None
+    ) -> None:
+        if tags is not None:
+            start_tag = f"<{kind} {tags}>"
+        else:
+            start_tag = f"<{kind}>"
+
+        if self.escape:
+            # escape & first to prevent double escaping of &
+            esc = {"&": r"&amp;", "<": r"&lt;", ">": r"&gt;"}
+        else:
+            esc = {}
+
+        rs = pprint_thing(s, escape_chars=esc).strip()
+
+        if self.render_links and is_url(rs):
+            rs_unescaped = pprint_thing(s, escape_chars={}).strip()
+            start_tag += f'<a href="{rs_unescaped}" target="_blank">'
+            end_a = "</a>"
+        else:
+            end_a = ""
+
+        self.write(f"{start_tag}{rs}{end_a}</{kind}>", indent)
+
+    def write_tr(
+        self,
+        line: Iterable,
+        indent: int = 0,
+        indent_delta: int = 0,
+        header: bool = False,
+        align: str | None = None,
+        tags: dict[int, str] | None = None,
+        nindex_levels: int = 0,
+    ) -> None:
+        if tags is None:
+            tags = {}
+
+        if align is None:
+            self.write("<tr>", indent)
+        else:
+            self.write(f'<tr style="text-align: {align};">', indent)
+        indent += indent_delta
+
+        for i, s in enumerate(line):
+            val_tag = tags.get(i, None)
+            if header or (self.bold_rows and i < nindex_levels):
+                self.write_th(s, indent=indent, header=header, tags=val_tag)
+            else:
+                self.write_td(s, indent, tags=val_tag)
+
+        indent -= indent_delta
+        self.write("</tr>", indent)
+
+    def _write_table(self, indent: int = 0) -> None:
+        _classes = ["dataframe"]  # Default class.
+        use_mathjax = get_option("display.html.use_mathjax")
+        if not use_mathjax:
+            _classes.append("tex2jax_ignore")
+        if self.classes is not None:
+            if isinstance(self.classes, str):
+                self.classes = self.classes.split()
+            if not isinstance(self.classes, (list, tuple)):
+                raise TypeError(
+                    "classes must be a string, list, "
+                    f"or tuple, not {type(self.classes)}"
+                )
+            _classes.extend(self.classes)
+
+        if self.table_id is None:
+            id_section = ""
+        else:
+            id_section = f' id="{self.table_id}"'
+
+        if self.border is None:
+            border_attr = ""
+        else:
+            border_attr = f' border="{self.border}"'
+
+        self.write(
+            f'<table{border_attr} class="{" ".join(_classes)}"{id_section}>',
+            indent,
+        )
+
+        if self.fmt.header or self.show_row_idx_names:
+            self._write_header(indent + self.indent_delta)
+
+        self._write_body(indent + self.indent_delta)
+
+        self.write("</table>", indent)
+
+    def _write_col_header(self, indent: int) -> None:
+        row: list[Hashable]
+        is_truncated_horizontally = self.fmt.is_truncated_horizontally
+        if isinstance(self.columns, MultiIndex):
+            template = 'colspan="{span:d}" halign="left"'
+
+            sentinel: lib.NoDefault | bool
+            if self.fmt.sparsify:
+                # GH3547
+                sentinel = lib.no_default
+            else:
+                sentinel = False
+            levels = self.columns._format_multi(sparsify=sentinel, include_names=False)
+            level_lengths = get_level_lengths(levels, sentinel)
+            inner_lvl = len(level_lengths) - 1
+            for lnum, (records, values) in enumerate(zip(level_lengths, levels)):
+                if is_truncated_horizontally:
+                    # modify the header lines
+                    ins_col = self.fmt.tr_col_num
+                    if self.fmt.sparsify:
+                        recs_new = {}
+                        # Increment tags after ... col.
+                        for tag, span in list(records.items()):
+                            if tag >= ins_col:
+                                recs_new[tag + 1] = span
+                            elif tag + span > ins_col:
+                                recs_new[tag] = span + 1
+                                if lnum == inner_lvl:
+                                    values = (
+                                        values[:ins_col] + ("...",) + values[ins_col:]
+                                    )
+                                else:
+                                    # sparse col headers do not receive a ...
+                                    values = (
+                                        values[:ins_col]
+                                        + (values[ins_col - 1],)
+                                        + values[ins_col:]
+                                    )
+                            else:
+                                recs_new[tag] = span
+                            # if ins_col lies between tags, all col headers
+                            # get ...
+                            if tag + span == ins_col:
+                                recs_new[ins_col] = 1
+                                values = values[:ins_col] + ("...",) + values[ins_col:]
+                        records = recs_new
+                        inner_lvl = len(level_lengths) - 1
+                        if lnum == inner_lvl:
+                            records[ins_col] = 1
+                    else:
+                        recs_new = {}
+                        for tag, span in list(records.items()):
+                            if tag >= ins_col:
+                                recs_new[tag + 1] = span
+                            else:
+                                recs_new[tag] = span
+                        recs_new[ins_col] = 1
+                        records = recs_new
+                        values = values[:ins_col] + ["..."] + values[ins_col:]
+
+                # see gh-22579
+                # Column Offset Bug with to_html(index=False) with
+                # MultiIndex Columns and Index.
+                # Initially fill row with blank cells before column names.
+                # TODO: Refactor to remove code duplication with code
+                # block below for standard columns index.
+                row = [""] * (self.row_levels - 1)
+                if self.fmt.index or self.show_col_idx_names:
+                    # see gh-22747
+                    # If to_html(index_names=False) do not show columns
+                    # index names.
+                    # TODO: Refactor to use _get_column_name_list from
+                    # DataFrameFormatter class and create a
+                    # _get_formatted_column_labels function for code
+                    # parity with DataFrameFormatter class.
+                    if self.fmt.show_index_names:
+                        name = self.columns.names[lnum]
+                        row.append(pprint_thing(name or ""))
+                    else:
+                        row.append("")
+
+                tags = {}
+                j = len(row)
+                for i, v in enumerate(values):
+                    if i in records:
+                        if records[i] > 1:
+                            tags[j] = template.format(span=records[i])
+                    else:
+                        continue
+                    j += 1
+                    row.append(v)
+                self.write_tr(row, indent, self.indent_delta, tags=tags, header=True)
+        else:
+            # see gh-22579
+            # Column misalignment also occurs for
+            # a standard index when the columns index is named.
+            # Initially fill row with blank cells before column names.
+            # TODO: Refactor to remove code duplication with code block
+            # above for columns MultiIndex.
+            row = [""] * (self.row_levels - 1)
+            if self.fmt.index or self.show_col_idx_names:
+                # see gh-22747
+                # If to_html(index_names=False) do not show columns
+                # index names.
+                # TODO: Refactor to use _get_column_name_list from
+                # DataFrameFormatter class.
+                if self.fmt.show_index_names:
+                    row.append(self.columns.name or "")
+                else:
+                    row.append("")
+            row.extend(self._get_columns_formatted_values())
+            align = self.fmt.justify
+
+            if is_truncated_horizontally:
+                ins_col = self.row_levels + self.fmt.tr_col_num
+                row.insert(ins_col, "...")
+
+            self.write_tr(row, indent, self.indent_delta, header=True, align=align)
+
+    def _write_row_header(self, indent: int) -> None:
+        is_truncated_horizontally = self.fmt.is_truncated_horizontally
+        row = [x if x is not None else "" for x in self.frame.index.names] + [""] * (
+            self.ncols + (1 if is_truncated_horizontally else 0)
+        )
+        self.write_tr(row, indent, self.indent_delta, header=True)
+
+    def _write_header(self, indent: int) -> None:
+        self.write("<thead>", indent)
+
+        if self.fmt.header:
+            self._write_col_header(indent + self.indent_delta)
+
+        if self.show_row_idx_names:
+            self._write_row_header(indent + self.indent_delta)
+
+        self.write("</thead>", indent)
+
+    def _get_formatted_values(self) -> dict[int, list[str]]:
+        with option_context("display.max_colwidth", None):
+            fmt_values = {i: self.fmt.format_col(i) for i in range(self.ncols)}
+        return fmt_values
+
+    def _write_body(self, indent: int) -> None:
+        self.write("<tbody>", indent)
+        fmt_values = self._get_formatted_values()
+
+        # write values
+        if self.fmt.index and isinstance(self.frame.index, MultiIndex):
+            self._write_hierarchical_rows(fmt_values, indent + self.indent_delta)
+        else:
+            self._write_regular_rows(fmt_values, indent + self.indent_delta)
+
+        self.write("</tbody>", indent)
+
+    def _write_regular_rows(
+        self, fmt_values: Mapping[int, list[str]], indent: int
+    ) -> None:
+        is_truncated_horizontally = self.fmt.is_truncated_horizontally
+        is_truncated_vertically = self.fmt.is_truncated_vertically
+
+        nrows = len(self.fmt.tr_frame)
+
+        if self.fmt.index:
+            fmt = self.fmt._get_formatter("__index__")
+            if fmt is not None:
+                index_values = self.fmt.tr_frame.index.map(fmt)
+            else:
+                # only reached with non-Multi index
+                index_values = self.fmt.tr_frame.index._format_flat(include_name=False)
+
+        row: list[str] = []
+        for i in range(nrows):
+            if is_truncated_vertically and i == (self.fmt.tr_row_num):
+                str_sep_row = ["..."] * len(row)
+                self.write_tr(
+                    str_sep_row,
+                    indent,
+                    self.indent_delta,
+                    tags=None,
+                    nindex_levels=self.row_levels,
+                )
+
+            row = []
+            if self.fmt.index:
+                row.append(index_values[i])
+            # see gh-22579
+            # Column misalignment also occurs for
+            # a standard index when the columns index is named.
+            # Add blank cell before data cells.
+            elif self.show_col_idx_names:
+                row.append("")
+            row.extend(fmt_values[j][i] for j in range(self.ncols))
+
+            if is_truncated_horizontally:
+                dot_col_ix = self.fmt.tr_col_num + self.row_levels
+                row.insert(dot_col_ix, "...")
+            self.write_tr(
+                row, indent, self.indent_delta, tags=None, nindex_levels=self.row_levels
+            )
+
+    def _write_hierarchical_rows(
+        self, fmt_values: Mapping[int, list[str]], indent: int
+    ) -> None:
+        template = 'rowspan="{span}" valign="top"'
+
+        is_truncated_horizontally = self.fmt.is_truncated_horizontally
+        is_truncated_vertically = self.fmt.is_truncated_vertically
+        frame = self.fmt.tr_frame
+        nrows = len(frame)
+
+        assert isinstance(frame.index, MultiIndex)
+        idx_values = frame.index._format_multi(sparsify=False, include_names=False)
+        idx_values = list(zip(*idx_values))
+
+        if self.fmt.sparsify:
+            # GH3547
+            sentinel = lib.no_default
+            levels = frame.index._format_multi(sparsify=sentinel, include_names=False)
+
+            level_lengths = get_level_lengths(levels, sentinel)
+            inner_lvl = len(level_lengths) - 1
+            if is_truncated_vertically:
+                # Insert ... row and adjust idx_values and
+                # level_lengths to take this into account.
+                ins_row = self.fmt.tr_row_num
+                inserted = False
+                for lnum, records in enumerate(level_lengths):
+                    rec_new = {}
+                    for tag, span in list(records.items()):
+                        if tag >= ins_row:
+                            rec_new[tag + 1] = span
+                        elif tag + span > ins_row:
+                            rec_new[tag] = span + 1
+
+                            # GH 14882 - Make sure insertion done once
+                            if not inserted:
+                                dot_row = list(idx_values[ins_row - 1])
+                                dot_row[-1] = "..."
+                                idx_values.insert(ins_row, tuple(dot_row))
+                                inserted = True
+                            else:
+                                dot_row = list(idx_values[ins_row])
+                                dot_row[inner_lvl - lnum] = "..."
+                                idx_values[ins_row] = tuple(dot_row)
+                        else:
+                            rec_new[tag] = span
+                        # If ins_row lies between tags, all cols idx cols
+                        # receive ...
+                        if tag + span == ins_row:
+                            rec_new[ins_row] = 1
+                            if lnum == 0:
+                                idx_values.insert(
+                                    ins_row, tuple(["..."] * len(level_lengths))
+                                )
+
+                            # GH 14882 - Place ... in correct level
+                            elif inserted:
+                                dot_row = list(idx_values[ins_row])
+                                dot_row[inner_lvl - lnum] = "..."
+                                idx_values[ins_row] = tuple(dot_row)
+                    level_lengths[lnum] = rec_new
+
+                level_lengths[inner_lvl][ins_row] = 1
+                for ix_col in fmt_values:
+                    fmt_values[ix_col].insert(ins_row, "...")
+                nrows += 1
+
+            for i in range(nrows):
+                row = []
+                tags = {}
+
+                sparse_offset = 0
+                j = 0
+                for records, v in zip(level_lengths, idx_values[i]):
+                    if i in records:
+                        if records[i] > 1:
+                            tags[j] = template.format(span=records[i])
+                    else:
+                        sparse_offset += 1
+                        continue
+
+                    j += 1
+                    row.append(v)
+
+                row.extend(fmt_values[j][i] for j in range(self.ncols))
+                if is_truncated_horizontally:
+                    row.insert(
+                        self.row_levels - sparse_offset + self.fmt.tr_col_num, "..."
+                    )
+                self.write_tr(
+                    row,
+                    indent,
+                    self.indent_delta,
+                    tags=tags,
+                    nindex_levels=len(levels) - sparse_offset,
+                )
+        else:
+            row = []
+            for i in range(len(frame)):
+                if is_truncated_vertically and i == (self.fmt.tr_row_num):
+                    str_sep_row = ["..."] * len(row)
+                    self.write_tr(
+                        str_sep_row,
+                        indent,
+                        self.indent_delta,
+                        tags=None,
+                        nindex_levels=self.row_levels,
+                    )
+
+                idx_values = list(
+                    zip(*frame.index._format_multi(sparsify=False, include_names=False))
+                )
+                row = []
+                row.extend(idx_values[i])
+                row.extend(fmt_values[j][i] for j in range(self.ncols))
+                if is_truncated_horizontally:
+                    row.insert(self.row_levels + self.fmt.tr_col_num, "...")
+                self.write_tr(
+                    row,
+                    indent,
+                    self.indent_delta,
+                    tags=None,
+                    nindex_levels=frame.index.nlevels,
+                )
+
+
+class NotebookFormatter(HTMLFormatter):
+    """
+    Internal class for formatting output data in html for display in Jupyter
+    Notebooks. This class is intended for functionality specific to
+    DataFrame._repr_html_() and DataFrame.to_html(notebook=True)
+    """
+
+    def _get_formatted_values(self) -> dict[int, list[str]]:
+        return {i: self.fmt.format_col(i) for i in range(self.ncols)}
+
+    def _get_columns_formatted_values(self) -> list[str]:
+        # only reached with non-Multi Index
+        return self.columns._format_flat(include_name=False)
+
+    def write_style(self) -> None:
+        # We use the "scoped" attribute here so that the desired
+        # style properties for the data frame are not then applied
+        # throughout the entire notebook.
+        template_first = """\
+            <style scoped>"""
+        template_last = """\
+            </style>"""
+        template_select = """\
+                .dataframe %s {
+                    %s: %s;
+                }"""
+        element_props = [
+            ("tbody tr th:only-of-type", "vertical-align", "middle"),
+            ("tbody tr th", "vertical-align", "top"),
+        ]
+        if isinstance(self.columns, MultiIndex):
+            element_props.append(("thead tr th", "text-align", "left"))
+            if self.show_row_idx_names:
+                element_props.append(
+                    ("thead tr:last-of-type th", "text-align", "right")
+                )
+        else:
+            element_props.append(("thead th", "text-align", "right"))
+        template_mid = "\n\n".join(template_select % t for t in element_props)
+        template = dedent(f"{template_first}\n{template_mid}\n{template_last}")
+        self.write(template)
+
+    def render(self) -> list[str]:
+        self.write("<div>")
+        self.write_style()
+        super().render()
+        self.write("</div>")
+        return self.elements