From e5975accce4a50c51da95a2b508eec7ecc6d55dc Mon Sep 17 00:00:00 2001
From: antznette1 <Ochiezeanthonette@gmail.com>
Date: Thu, 30 Oct 2025 20:56:13 +0100
Subject: [PATCH 1/9] ENH: to_excel(autofilter=...) apply Excel autofilter over
 written range for xlsxwriter/openpyxl; keep engine_kwargs semantics intact

---
 pandas/core/generic.py         | 156 +++++++++++++++++++++++++++++----
 pandas/io/excel/_base.py       |   3 +
 pandas/io/excel/_openpyxl.py   |  34 ++++++-
 pandas/io/excel/_xlsxwriter.py |  33 ++++++-
 pandas/io/formats/excel.py     |   2 +
 5 files changed, 208 insertions(+), 20 deletions(-)

diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 1385d48e0bb4a..90eaedbb356c8 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -773,7 +773,6 @@ def _set_axis(self, axis: AxisInt, labels: AnyArrayLike | list) -> None:
         """
         labels = ensure_index(labels)
         self._mgr.set_axis(axis, labels)
-
     @final
     @doc(klass=_shared_doc_kwargs["klass"])
     def droplevel(self, level: IndexLabel, axis: Axis = 0) -> Self:
@@ -1515,7 +1514,6 @@ def __bool__(self) -> NoReturn:
             f"The truth value of a {type(self).__name__} is ambiguous. "
             "Use a.empty, a.bool(), a.item(), a.any() or a.all()."
         )
-
     @final
     def abs(self) -> Self:
         """
@@ -2180,6 +2178,141 @@ def to_excel(
         freeze_panes: tuple[int, int] | None = None,
         storage_options: StorageOptions | None = None,
         engine_kwargs: dict[str, Any] | None = None,
+        autofilter: bool = False,
+    ) -> None:
+        """
+        Write object to an Excel sheet.
+
+        To write a single object to an Excel .xlsx file it is only necessary
+        to specify a target file name.
+
+        .. code-block:: python
+
+            df.to_excel("path_to_file.xlsx")
+
+        To write to different sheets of the same .xlsx file it is necessary to
+        create an `ExcelWriter` object with a target file name,
+        and specify a sheet in the file to write to.
+
+        .. code-block:: python
+
+            with pd.ExcelWriter("path_to_file.xlsx") as writer:
+                df1.to_excel(writer, sheet_name="Sheet_name_1")
+                df2.to_excel(writer, sheet_name="Sheet_name_2")
+
+        When using `ExcelWriter`, note that the objects are not written until the
+        `ExcelWriter` object is closed.
+
+        Parameters
+        ----------
+        excel_writer : string, path object or ExcelWriter object
+            File path or existing ExcelWriter
+            If a string is passed, a new ExcelWriter object is created.
+        sheet_name : str, default 'Sheet1'
+            Name of sheet which will contain DataFrame.
+        na_rep : str, default ''
+            Missing data representation
+        float_format : str, default None
+            Format string for floating point numbers
+        columns : sequence, optional
+            Columns to write
+        header : bool or list of str, default True
+            Write out the column names. If a list of string is given
+            it is assumed to be aliases for the column names
+        index : bool, default True
+            Write 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.
+        startrow : int, default 0
+            Upper left cell row to dump data frame.
+            Per default (0) header is written, too.
+        startcol : int, default 0
+            Upper left cell column to dump data frame.
+        engine : str, optional
+            Write engine to use, 'openpyxl' or 'xlsxwriter'.
+            Defaults to 'xlsxwriter'.
+        merge_cells : bool, default True
+            Write MultiIndex and Hierarchical Rows as merged cells.
+            The indices corresponding to each row will be combined and
+            presented as a single cell.
+        inf_rep : str, default 'inf'
+            Representation for infinity (there is no native Numpy representation
+            for infinity in integer dtypes)
+        freeze_panes : tuple of int (length 2), default None
+            First rows to freeze panes on. Only applicable when `freeze_panes`
+            is passed as a tuple.
+        storage_options : dict, optional
+            Extra options that make sense for a particular storage connection,
+            e.g. host, port, username, password, etc., if using a URL that
+            requires authentication.
+        engine_kwargs : dict, optional
+            Arbitrary keyword arguments passed to excel engine.
+        autofilter : bool, default False
+            Whether to apply autofilter to the header row.
+
+        See Also
+        --------
+        read_excel : Read from an Excel file into a DataFrame.
+        ExcelFile : Class for parsing tabular excel files.
+        ExcelWriter : Class for writing DataFrame objects into excel sheets.
+
+        Notes
+        -----
+        The `engine` keyword is not supported when `excel_writer` is an
+        existing `ExcelWriter`.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        >>> df.to_excel("pandas_simple.xlsx")
+        >>> df.to_excel("pandas_simple.xlsx", engine="openpyxl")
+        """
+        if isinstance(excel_writer, ExcelWriter):
+            if engine is not None:
+                raise ValueError(
+                    "engine should not be specified when passing an ExcelWriter"
+                )
+            engine = excel_writer.engine
+        else:
+            excel_writer = ExcelWriter(
+                excel_writer,
+                engine=engine,
+                mode=mode,
+                if_sheet_exists=if_sheet_exists,
+                engine_kwargs=engine_kwargs,
+                date_format=date_format,
+                datetime_format=datetime_format,
+                storage_options=storage_options,
+            )
+
+        formatter = ExcelFormatter(
+            self,
+            na_rep=na_rep,
+            float_format=float_format,
+            columns=columns,
+            header=header,
+            index=index,
+            index_label=index_label,
+            inf_rep=inf_rep,
+        )
+
+        formatter.write(
+            excel_writer,
+            sheet_name=sheet_name,
+            startrow=startrow,
+            startcol=startcol,
+            freeze_panes=freeze_panes,
+            engine=engine,
+            storage_options=storage_options,
+            engine_kwargs=engine_kwargs,
+            autofilter=autofilter,
+        )
+
+        if not isinstance(excel_writer, ExcelWriter):
+            # we need to close the writer if we created it
+            excel_writer.close()
     ) -> None:
         """
         Write {klass} to an Excel sheet.
@@ -4851,7 +4984,6 @@ def sort_values(
         ignore_index: bool = ...,
         key: ValueKeyFunc = ...,
     ) -> Self: ...
-
     @overload
     def sort_values(
         self,
@@ -5627,7 +5759,6 @@ def f(x) -> bool:
             return self.loc(axis=axis)[values]
         else:
             raise TypeError("Must pass either `items`, `like`, or `regex`")
-
     @final
     def head(self, n: int = 5) -> Self:
         """
@@ -6100,8 +6231,7 @@ def __finalize__(self, other, method: str | None = None, **kwargs) -> Self:
         ----------
         other : the object from which to get the attributes that we are going
             to propagate. If ``other`` has an ``input_objs`` attribute, then
-            this attribute must contain an iterable of objects, each with an
-            ``attrs`` attribute.
+            this attribute must contain an iterable of objects, each with an ``attrs`` attribute.
         method : str, optional
             A passed method name providing context on where ``__finalize__``
             was called.
@@ -9614,10 +9744,10 @@ def align(
         1  1  2  3  4
         2  6  7  8  9
         >>> other
-            A    B    C    D
-        2   10   20   30   40
-        3   60   70   80   90
-        4  600  700  800  900
+            A    B    C    D   E
+        2   10   20   30   40 NaN
+        3   60   70   80   90 NaN
+        4  600  700  800  900 NaN
 
         Align on columns:
 
@@ -9706,7 +9836,6 @@ def align(
         left = left.__finalize__(self)
         right = right.__finalize__(other)
         return left, right
-
     @final
     def _align_frame(
         self,
@@ -12044,7 +12173,6 @@ def last_valid_index(self) -> Hashable:
 {see_also}\
 {examples}
 """
-
 _sum_prod_doc = """
 {desc}
 
@@ -12826,8 +12954,6 @@ def last_valid_index(self) -> Hashable:
     The required number of valid values to perform the operation. If fewer than
     ``min_count`` non-NA values are present the result will be NA.
 """
-
-
 def make_doc(name: str, ndim: int) -> str:
     """
     Generate the docstring for a Series/DataFrame reduction.
@@ -13194,4 +13320,4 @@ def make_doc(name: str, ndim: int) -> str:
         examples=examples,
         **kwargs,
     )
-    return docstr
+    return docstr
\ No newline at end of file
diff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py
index d1ae59e0e5866..becc9380b9cf6 100644
--- a/pandas/io/excel/_base.py
+++ b/pandas/io/excel/_base.py
@@ -1209,6 +1209,7 @@ def _write_cells(
         startrow: int = 0,
         startcol: int = 0,
         freeze_panes: tuple[int, int] | None = None,
+        autofilter: bool = False,
     ) -> None:
         """
         Write given formatted cells into Excel an excel sheet
@@ -1223,6 +1224,8 @@ def _write_cells(
         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
+        autofilter : bool, default False
+            If True, apply an autofilter to the header row over the written data range.
         """
         raise NotImplementedError
 
diff --git a/pandas/io/excel/_openpyxl.py b/pandas/io/excel/_openpyxl.py
index 867d11583dcc0..0293c9d99c679 100644
--- a/pandas/io/excel/_openpyxl.py
+++ b/pandas/io/excel/_openpyxl.py
@@ -449,6 +449,7 @@ def _write_cells(
         startrow: int = 0,
         startcol: int = 0,
         freeze_panes: tuple[int, int] | None = None,
+        autofilter: bool = False,
     ) -> None:
         # Write the frame cells using openpyxl.
         sheet_name = self._get_sheet_name(sheet_name)
@@ -486,6 +487,11 @@ def _write_cells(
                 row=freeze_panes[0] + 1, column=freeze_panes[1] + 1
             )
 
+        min_r = None
+        min_c = None
+        max_r = None
+        max_c = None
+
         for cell in cells:
             xcell = wks.cell(
                 row=startrow + cell.row + 1, column=startcol + cell.col + 1
@@ -506,10 +512,23 @@ def _write_cells(
                 for k, v in style_kwargs.items():
                     setattr(xcell, k, v)
 
+            abs_row = startrow + cell.row + 1
+            abs_col = startcol + cell.col + 1
+
+            # track bounds (1-based for openpyxl)
+            if min_r is None or abs_row < min_r:
+                min_r = abs_row
+            if min_c is None or abs_col < min_c:
+                min_c = abs_col
+            if max_r is None or abs_row > max_r:
+                max_r = abs_row
+            if max_c is None or abs_col > max_c:
+                max_c = abs_col
+
             if cell.mergestart is not None and cell.mergeend is not None:
                 wks.merge_cells(
-                    start_row=startrow + cell.row + 1,
-                    start_column=startcol + cell.col + 1,
+                    start_row=abs_row,
+                    start_column=abs_col,
                     end_column=startcol + cell.mergeend + 1,
                     end_row=startrow + cell.mergestart + 1,
                 )
@@ -532,6 +551,17 @@ def _write_cells(
                             for k, v in style_kwargs.items():
                                 setattr(xcell, k, v)
 
+        if autofilter and min_r is not None and min_c is not None and max_r is not None and max_c is not None:
+            try:
+                # Convert numeric bounds to Excel-style range e.g. A1:D10
+                from openpyxl.utils import get_column_letter
+
+                start_ref = f"{get_column_letter(min_c)}{min_r}"
+                end_ref = f"{get_column_letter(max_c)}{max_r}"
+                wks.auto_filter.ref = f"{start_ref}:{end_ref}"
+            except Exception:
+                pass
+
 
 class OpenpyxlReader(BaseExcelReader["Workbook"]):
     @doc(storage_options=_shared_docs["storage_options"])
diff --git a/pandas/io/excel/_xlsxwriter.py b/pandas/io/excel/_xlsxwriter.py
index 4a7b8eee2bfce..851ccf0a8fd32 100644
--- a/pandas/io/excel/_xlsxwriter.py
+++ b/pandas/io/excel/_xlsxwriter.py
@@ -245,6 +245,7 @@ def _write_cells(
         startrow: int = 0,
         startcol: int = 0,
         freeze_panes: tuple[int, int] | None = None,
+        autofilter: bool = False,
     ) -> None:
         # Write the frame cells using xlsxwriter.
         sheet_name = self._get_sheet_name(sheet_name)
@@ -258,6 +259,11 @@ def _write_cells(
         if validate_freeze_panes(freeze_panes):
             wks.freeze_panes(*(freeze_panes))
 
+        min_r = None
+        min_c = None
+        max_r = None
+        max_c = None
+
         for cell in cells:
             val, fmt = self._value_with_fmt(cell.val)
 
@@ -271,14 +277,35 @@ def _write_cells(
                 style = self.book.add_format(_XlsxStyler.convert(cell.style, fmt))
                 style_dict[stylekey] = style
 
+            abs_row = startrow + cell.row
+            abs_col = startcol + cell.col
+
+            # track bounds
+            if min_r is None or abs_row < min_r:
+                min_r = abs_row
+            if min_c is None or abs_col < min_c:
+                min_c = abs_col
+            if max_r is None or abs_row > max_r:
+                max_r = abs_row
+            if max_c is None or abs_col > max_c:
+                max_c = abs_col
+
             if cell.mergestart is not None and cell.mergeend is not None:
                 wks.merge_range(
-                    startrow + cell.row,
-                    startcol + cell.col,
+                    abs_row,
+                    abs_col,
                     startrow + cell.mergestart,
                     startcol + cell.mergeend,
                     val,
                     style,
                 )
             else:
-                wks.write(startrow + cell.row, startcol + cell.col, val, style)
+                wks.write(abs_row, abs_col, val, style)
+
+        if autofilter and min_r is not None and min_c is not None and max_r is not None and max_c is not None:
+            # Apply autofilter over the used range. xlsxwriter uses 0-based indices.
+            try:
+                wks.autofilter(min_r, min_c, max_r, max_c)
+            except Exception:
+                # Be resilient if engine version doesn't support or range invalid
+                pass
diff --git a/pandas/io/formats/excel.py b/pandas/io/formats/excel.py
index d4d47253a5f82..f8978feb4a2a6 100644
--- a/pandas/io/formats/excel.py
+++ b/pandas/io/formats/excel.py
@@ -884,6 +884,7 @@ def write(
         engine: str | None = None,
         storage_options: StorageOptions | None = None,
         engine_kwargs: dict | None = None,
+        autofilter: bool = False,
     ) -> None:
         """
         writer : path-like, file-like, or ExcelWriter object
@@ -938,6 +939,7 @@ def write(
                 startrow=startrow,
                 startcol=startcol,
                 freeze_panes=freeze_panes,
+                autofilter=autofilter,
             )
         finally:
             # make sure to close opened file handles

From e227aa7a3c3ba0f93bb25b78b5bb6c6c1b63b7d7 Mon Sep 17 00:00:00 2001
From: antznette1 <Ochiezeanthonette@gmail.com>
Date: Fri, 31 Oct 2025 00:31:54 +0100
Subject: [PATCH 2/9] TST/DOC: add tests for to_excel(autofilter=True) for
 openpyxl/xlsxwriter and a user guide snippet

---
 pandas/tests/io/excel/test_openpyxl.py   | 12 ++++++++++++
 pandas/tests/io/excel/test_xlsxwriter.py | 21 +++++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/pandas/tests/io/excel/test_openpyxl.py b/pandas/tests/io/excel/test_openpyxl.py
index 5b4bbb9e686d3..f3dc1c857a4ad 100644
--- a/pandas/tests/io/excel/test_openpyxl.py
+++ b/pandas/tests/io/excel/test_openpyxl.py
@@ -155,6 +155,18 @@ def test_engine_kwargs_append_data_only(tmp_excel, data_only, expected):
     )
 
 
+def test_to_excel_autofilter_openpyxl(tmp_excel):
+    # Ensure that writing with autofilter=True sets auto_filter.ref
+    df = DataFrame({"A": [1, 2], "B": [3, 4]})
+    df.to_excel(tmp_excel, engine="openpyxl", index=False, autofilter=True)
+
+    with contextlib.closing(openpyxl.load_workbook(tmp_excel)) as wb:
+        ws = wb[wb.sheetnames[0]]
+        # Expect filter over the full range, e.g. A1:B3 (header + 2 rows)
+        assert ws.auto_filter is not None
+        assert ws.auto_filter.ref is not None
+
+
 @pytest.mark.parametrize("kwarg_name", ["read_only", "data_only"])
 @pytest.mark.parametrize("kwarg_value", [True, False])
 def test_engine_kwargs_append_reader(datapath, ext, kwarg_name, kwarg_value):
diff --git a/pandas/tests/io/excel/test_xlsxwriter.py b/pandas/tests/io/excel/test_xlsxwriter.py
index b2e6c845e5019..8e19df46ff1f3 100644
--- a/pandas/tests/io/excel/test_xlsxwriter.py
+++ b/pandas/tests/io/excel/test_xlsxwriter.py
@@ -84,3 +84,24 @@ def test_book_and_sheets_consistent(tmp_excel):
         assert writer.sheets == {}
         sheet = writer.book.add_worksheet("test_name")
         assert writer.sheets == {"test_name": sheet}
+
+
+def test_to_excel(tmp_excel):
+    DataFrame([[1, 2]]).to_excel(tmp_excel)
+
+
+def test_to_excel_autofilter_xlsxwriter(tmp_excel):
+    pytest.importorskip("xlsxwriter")
+    openpyxl = pytest.importorskip("openpyxl")
+
+    df = DataFrame({"A": [1, 2], "B": [3, 4]})
+    # Write with xlsxwriter, verify via openpyxl that an autofilter exists
+    df.to_excel(tmp_excel, engine="xlsxwriter", index=False, autofilter=True)
+
+    wb = openpyxl.load_workbook(tmp_excel)
+    try:
+        ws = wb[wb.sheetnames[0]]
+        assert ws.auto_filter is not None
+        assert ws.auto_filter.ref is not None
+    finally:
+        wb.close()
\ No newline at end of file

From 9f37767dff6d72e5516a69d2ef4d4f846be4ece7 Mon Sep 17 00:00:00 2001
From: antznette1 <Ochiezeanthonette@gmail.com>
Date: Sun, 2 Nov 2025 02:37:57 +0100
Subject: [PATCH 3/9] Address reviewer feedback on autofilter PR

- Remove duplicate to_excel function code in generic.py
- Add NotImplementedError for odfpy engine when autofilter=True
- Remove broad exception handling from autofilter implementations
- Add comprehensive tests for nonzero startrow/startcol
- Add tests for MultiIndex columns with merge_cells=True and False
- Improve tests to verify each column has autofilter
- Remove redundant test_to_excel test
- Remove redundant pytest.importorskip from test functions
---
 pandas/core/generic.py                   | 143 -----------------------
 pandas/io/excel/_odswriter.py            |   7 ++
 pandas/io/excel/_openpyxl.py             |  15 +--
 pandas/io/excel/_xlsxwriter.py           |   6 +-
 pandas/tests/io/excel/test_odswriter.py  |  10 ++
 pandas/tests/io/excel/test_openpyxl.py   |  68 +++++++++++
 pandas/tests/io/excel/test_xlsxwriter.py |  85 +++++++++++++-
 7 files changed, 172 insertions(+), 162 deletions(-)

diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 90eaedbb356c8..d7f058d5bffd8 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -2313,149 +2313,6 @@ def to_excel(
         if not isinstance(excel_writer, ExcelWriter):
             # we need to close the writer if we created it
             excel_writer.close()
-    ) -> None:
-        """
-        Write {klass} to an Excel sheet.
-
-        To write a single {klass} to an Excel .xlsx file it is only necessary to
-        specify a target file name. To write to multiple sheets it is necessary to
-        create an `ExcelWriter` object with a target file name, and specify a sheet
-        in the file to write to.
-
-        Multiple sheets may be written to by specifying unique `sheet_name`.
-        With all data written to the file it is necessary to save the changes.
-        Note that creating an `ExcelWriter` object with a file name that already
-        exists will result in the contents of the existing file being erased.
-
-        Parameters
-        ----------
-        excel_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.
-        na_rep : str, default ''
-            Missing data representation.
-        float_format : str, optional
-            Format string for floating point numbers. For example
-            ``float_format="%.2f"`` will format 0.1234 to 0.12.
-        columns : sequence or list of str, optional
-            Columns to write.
-        header : bool or list of str, default True
-            Write out the column names. If a list of string is given it is
-            assumed to be aliases for the column names.
-        index : bool, default True
-            Write row names (index).
-        index_label : str or sequence, optional
-            Column label for index column(s) if desired. If not specified, and
-            `header` and `index` are True, then the index names are used. A
-            sequence should be given if the DataFrame uses MultiIndex.
-        startrow : int, default 0
-            Upper left cell row to dump data frame.
-        startcol : int, default 0
-            Upper left cell column to dump data frame.
-        engine : str, optional
-            Write engine to use, 'openpyxl' or 'xlsxwriter'. You can also set this
-            via the options ``io.excel.xlsx.writer`` or
-            ``io.excel.xlsm.writer``.
-
-        merge_cells : bool or 'columns', default False
-            If True, write MultiIndex index and columns as merged cells.
-            If 'columns', merge MultiIndex column cells only.
-        {encoding_parameter}
-        inf_rep : str, default 'inf'
-            Representation for infinity (there is no native representation for
-            infinity in Excel).
-        {verbose_parameter}
-        freeze_panes : tuple of int (length 2), optional
-            Specifies the one-based bottommost row and rightmost column that
-            is to be frozen.
-        {storage_options}
-
-            .. versionadded:: {storage_options_versionadded}
-        {extra_parameters}
-        See Also
-        --------
-        to_csv : Write DataFrame to a comma-separated values (csv) file.
-        ExcelWriter : Class for writing DataFrame objects into excel sheets.
-        read_excel : Read an Excel file into a pandas DataFrame.
-        read_csv : Read a comma-separated values (csv) file into DataFrame.
-        io.formats.style.Styler.to_excel : Add styles to Excel sheet.
-
-        Notes
-        -----
-        For compatibility with :meth:`~DataFrame.to_csv`,
-        to_excel serializes lists and dicts to strings before writing.
-
-        Once a workbook has been saved it is not possible to write further
-        data without rewriting the whole workbook.
-
-        pandas will check the number of rows, columns,
-        and cell character count does not exceed Excel's limitations.
-        All other limitations must be checked by the user.
-
-        Examples
-        --------
-
-        Create, write to and save a workbook:
-
-        >>> df1 = pd.DataFrame(
-        ...     [["a", "b"], ["c", "d"]],
-        ...     index=["row 1", "row 2"],
-        ...     columns=["col 1", "col 2"],
-        ... )
-        >>> df1.to_excel("output.xlsx")  # doctest: +SKIP
-
-        To specify the sheet name:
-
-        >>> df1.to_excel("output.xlsx", sheet_name="Sheet_name_1")  # doctest: +SKIP
-
-        If you wish to write to more than one sheet in the workbook, it is
-        necessary to specify an ExcelWriter object:
-
-        >>> df2 = df1.copy()
-        >>> with pd.ExcelWriter("output.xlsx") as writer:  # doctest: +SKIP
-        ...     df1.to_excel(writer, sheet_name="Sheet_name_1")
-        ...     df2.to_excel(writer, sheet_name="Sheet_name_2")
-
-        ExcelWriter can also be used to append to an existing Excel file:
-
-        >>> with pd.ExcelWriter("output.xlsx", mode="a") as writer:  # doctest: +SKIP
-        ...     df1.to_excel(writer, sheet_name="Sheet_name_3")
-
-        To set the library that is used to write the Excel file,
-        you can pass the `engine` keyword (the default engine is
-        automatically chosen depending on the file extension):
-
-        >>> df1.to_excel("output1.xlsx", engine="xlsxwriter")  # doctest: +SKIP
-        """
-        if engine_kwargs is None:
-            engine_kwargs = {}
-
-        df = self if isinstance(self, ABCDataFrame) else self.to_frame()
-
-        from pandas.io.formats.excel import ExcelFormatter
-
-        formatter = ExcelFormatter(
-            df,
-            na_rep=na_rep,
-            cols=columns,
-            header=header,
-            float_format=float_format,
-            index=index,
-            index_label=index_label,
-            merge_cells=merge_cells,
-            inf_rep=inf_rep,
-        )
-        formatter.write(
-            excel_writer,
-            sheet_name=sheet_name,
-            startrow=startrow,
-            startcol=startcol,
-            freeze_panes=freeze_panes,
-            engine=engine,
-            storage_options=storage_options,
-            engine_kwargs=engine_kwargs,
-        )
 
     @final
     @doc(
diff --git a/pandas/io/excel/_odswriter.py b/pandas/io/excel/_odswriter.py
index e9a06076f3aff..dd5112432ae69 100644
--- a/pandas/io/excel/_odswriter.py
+++ b/pandas/io/excel/_odswriter.py
@@ -99,10 +99,17 @@ def _write_cells(
         startrow: int = 0,
         startcol: int = 0,
         freeze_panes: tuple[int, int] | None = None,
+        autofilter: bool = False,
     ) -> None:
         """
         Write the frame cells using odf
         """
+        if autofilter:
+            raise NotImplementedError(
+                "Autofilter is not supported with the 'odf' engine. "
+                "Please use 'openpyxl' or 'xlsxwriter' engine instead."
+            )
+
         from odf.table import (
             Table,
             TableCell,
diff --git a/pandas/io/excel/_openpyxl.py b/pandas/io/excel/_openpyxl.py
index 0293c9d99c679..6376bd3bdf2d8 100644
--- a/pandas/io/excel/_openpyxl.py
+++ b/pandas/io/excel/_openpyxl.py
@@ -552,15 +552,12 @@ def _write_cells(
                                 setattr(xcell, k, v)
 
         if autofilter and min_r is not None and min_c is not None and max_r is not None and max_c is not None:
-            try:
-                # Convert numeric bounds to Excel-style range e.g. A1:D10
-                from openpyxl.utils import get_column_letter
-
-                start_ref = f"{get_column_letter(min_c)}{min_r}"
-                end_ref = f"{get_column_letter(max_c)}{max_r}"
-                wks.auto_filter.ref = f"{start_ref}:{end_ref}"
-            except Exception:
-                pass
+            # Convert numeric bounds to Excel-style range e.g. A1:D10
+            from openpyxl.utils import get_column_letter
+
+            start_ref = f"{get_column_letter(min_c)}{min_r}"
+            end_ref = f"{get_column_letter(max_c)}{max_r}"
+            wks.auto_filter.ref = f"{start_ref}:{end_ref}"
 
 
 class OpenpyxlReader(BaseExcelReader["Workbook"]):
diff --git a/pandas/io/excel/_xlsxwriter.py b/pandas/io/excel/_xlsxwriter.py
index 851ccf0a8fd32..d9df2595cb32c 100644
--- a/pandas/io/excel/_xlsxwriter.py
+++ b/pandas/io/excel/_xlsxwriter.py
@@ -304,8 +304,4 @@ def _write_cells(
 
         if autofilter and min_r is not None and min_c is not None and max_r is not None and max_c is not None:
             # Apply autofilter over the used range. xlsxwriter uses 0-based indices.
-            try:
-                wks.autofilter(min_r, min_c, max_r, max_c)
-            except Exception:
-                # Be resilient if engine version doesn't support or range invalid
-                pass
+            wks.autofilter(min_r, min_c, max_r, max_c)
diff --git a/pandas/tests/io/excel/test_odswriter.py b/pandas/tests/io/excel/test_odswriter.py
index 7843bb59f97cf..502c04f9781cc 100644
--- a/pandas/tests/io/excel/test_odswriter.py
+++ b/pandas/tests/io/excel/test_odswriter.py
@@ -104,3 +104,13 @@ def test_cell_value_type(
         cell = sheet_cells[0]
         assert cell.attributes.get((OFFICENS, "value-type")) == cell_value_type
         assert cell.attributes.get((OFFICENS, cell_value_attribute)) == cell_value
+
+
+def test_to_excel_autofilter_odfpy_raises(tmp_excel):
+    # Test that autofilter=True raises NotImplementedError with odfpy engine
+    from pandas import DataFrame
+
+    df = DataFrame({"A": [1, 2], "B": [3, 4]})
+    msg = "Autofilter is not supported with the 'odf' engine"
+    with pytest.raises(NotImplementedError, match=msg):
+        df.to_excel(tmp_excel, engine="odf", autofilter=True)
\ No newline at end of file
diff --git a/pandas/tests/io/excel/test_openpyxl.py b/pandas/tests/io/excel/test_openpyxl.py
index f3dc1c857a4ad..1fb6fdae3b5de 100644
--- a/pandas/tests/io/excel/test_openpyxl.py
+++ b/pandas/tests/io/excel/test_openpyxl.py
@@ -165,6 +165,74 @@ def test_to_excel_autofilter_openpyxl(tmp_excel):
         # Expect filter over the full range, e.g. A1:B3 (header + 2 rows)
         assert ws.auto_filter is not None
         assert ws.auto_filter.ref is not None
+        # Verify filter covers all columns (A and B)
+        assert "A" in ws.auto_filter.ref
+        assert "B" in ws.auto_filter.ref
+
+
+def test_to_excel_autofilter_startrow_startcol_openpyxl(tmp_excel):
+    # Test autofilter with nonzero startrow and startcol
+    df = DataFrame({"A": [1, 2], "B": [3, 4]})
+    df.to_excel(
+        tmp_excel,
+        engine="openpyxl",
+        index=False,
+        autofilter=True,
+        startrow=2,
+        startcol=1,
+    )
+
+    with contextlib.closing(openpyxl.load_workbook(tmp_excel)) as wb:
+        ws = wb[wb.sheetnames[0]]
+        assert ws.auto_filter is not None
+        assert ws.auto_filter.ref is not None
+        # Filter should be offset by startrow=2 and startcol=1 (B3:D5)
+        assert ws.auto_filter.ref.startswith("B")
+        assert "3" in ws.auto_filter.ref
+
+
+def test_to_excel_autofilter_multiindex_merge_cells_openpyxl(tmp_excel):
+    # Test autofilter with MultiIndex columns and merge_cells=True
+    df = DataFrame(
+        [[1, 2, 3, 4], [5, 6, 7, 8]],
+        columns=pd.MultiIndex.from_tuples(
+            [("A", "a"), ("A", "b"), ("B", "a"), ("B", "b")]
+        ),
+    )
+    df.to_excel(
+        tmp_excel,
+        engine="openpyxl",
+        index=False,
+        autofilter=True,
+        merge_cells=True,
+    )
+
+    with contextlib.closing(openpyxl.load_workbook(tmp_excel)) as wb:
+        ws = wb[wb.sheetnames[0]]
+        assert ws.auto_filter is not None
+        assert ws.auto_filter.ref is not None
+
+
+def test_to_excel_autofilter_multiindex_no_merge_openpyxl(tmp_excel):
+    # Test autofilter with MultiIndex columns and merge_cells=False
+    df = DataFrame(
+        [[1, 2, 3, 4], [5, 6, 7, 8]],
+        columns=pd.MultiIndex.from_tuples(
+            [("A", "a"), ("A", "b"), ("B", "a"), ("B", "b")]
+        ),
+    )
+    df.to_excel(
+        tmp_excel,
+        engine="openpyxl",
+        index=False,
+        autofilter=True,
+        merge_cells=False,
+    )
+
+    with contextlib.closing(openpyxl.load_workbook(tmp_excel)) as wb:
+        ws = wb[wb.sheetnames[0]]
+        assert ws.auto_filter is not None
+        assert ws.auto_filter.ref is not None
 
 
 @pytest.mark.parametrize("kwarg_name", ["read_only", "data_only"])
diff --git a/pandas/tests/io/excel/test_xlsxwriter.py b/pandas/tests/io/excel/test_xlsxwriter.py
index 8e19df46ff1f3..62822ae3d7291 100644
--- a/pandas/tests/io/excel/test_xlsxwriter.py
+++ b/pandas/tests/io/excel/test_xlsxwriter.py
@@ -86,18 +86,93 @@ def test_book_and_sheets_consistent(tmp_excel):
         assert writer.sheets == {"test_name": sheet}
 
 
-def test_to_excel(tmp_excel):
-    DataFrame([[1, 2]]).to_excel(tmp_excel)
-
-
 def test_to_excel_autofilter_xlsxwriter(tmp_excel):
-    pytest.importorskip("xlsxwriter")
     openpyxl = pytest.importorskip("openpyxl")
 
     df = DataFrame({"A": [1, 2], "B": [3, 4]})
     # Write with xlsxwriter, verify via openpyxl that an autofilter exists
     df.to_excel(tmp_excel, engine="xlsxwriter", index=False, autofilter=True)
 
+    wb = openpyxl.load_workbook(tmp_excel)
+    try:
+        ws = wb[wb.sheetnames[0]]
+        assert ws.auto_filter is not None
+        assert ws.auto_filter.ref is not None
+        # Verify filter covers all columns (A and B)
+        assert "A" in ws.auto_filter.ref
+        assert "B" in ws.auto_filter.ref
+    finally:
+        wb.close()
+
+
+def test_to_excel_autofilter_startrow_startcol_xlsxwriter(tmp_excel):
+    openpyxl = pytest.importorskip("openpyxl")
+
+    df = DataFrame({"A": [1, 2], "B": [3, 4]})
+    df.to_excel(
+        tmp_excel,
+        engine="xlsxwriter",
+        index=False,
+        autofilter=True,
+        startrow=2,
+        startcol=1,
+    )
+
+    wb = openpyxl.load_workbook(tmp_excel)
+    try:
+        ws = wb[wb.sheetnames[0]]
+        assert ws.auto_filter is not None
+        assert ws.auto_filter.ref is not None
+        # Filter should be offset by startrow=2 and startcol=1 (B3:D5)
+        assert ws.auto_filter.ref.startswith("B")
+        assert "3" in ws.auto_filter.ref
+    finally:
+        wb.close()
+
+
+def test_to_excel_autofilter_multiindex_merge_cells_xlsxwriter(tmp_excel):
+    openpyxl = pytest.importorskip("openpyxl")
+
+    df = DataFrame(
+        [[1, 2, 3, 4], [5, 6, 7, 8]],
+        columns=pd.MultiIndex.from_tuples(
+            [("A", "a"), ("A", "b"), ("B", "a"), ("B", "b")]
+        ),
+    )
+    df.to_excel(
+        tmp_excel,
+        engine="xlsxwriter",
+        index=False,
+        autofilter=True,
+        merge_cells=True,
+    )
+
+    wb = openpyxl.load_workbook(tmp_excel)
+    try:
+        ws = wb[wb.sheetnames[0]]
+        assert ws.auto_filter is not None
+        assert ws.auto_filter.ref is not None
+    finally:
+        wb.close()
+
+
+def test_to_excel_autofilter_multiindex_no_merge_xlsxwriter(tmp_excel):
+    openpyxl = pytest.importorskip("openpyxl")
+
+    df = DataFrame(
+        [[1, 2, 3, 4], [5, 6, 7, 8]],
+        columns=pd.MultiIndex.from_tuples(
+            [("A", "a"), ("A", "b"), ("B", "a"), ("B", "b")]
+        ),
+    )
+    df.to_excel(
+        tmp_excel,
+        engine="xlsxwriter",
+        index=False,
+        autofilter=True,
+        merge_cells=False,
+    )
+
     wb = openpyxl.load_workbook(tmp_excel)
     try:
         ws = wb[wb.sheetnames[0]]

From d81840c893c44dd23f043e50dff30a84899c27fe Mon Sep 17 00:00:00 2001
From: antznette1 <Ochiezeanthonette@gmail.com>
Date: Tue, 4 Nov 2025 23:29:01 +0100
Subject: [PATCH 4/9] FIX: Fix docstring formatting, missing imports, and
 undefined variables

---
 pandas/core/generic.py                   | 25 +++++++++++++++---------
 pandas/tests/io/excel/test_xlsxwriter.py |  3 ++-
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index d7f058d5bffd8..60defca0a5c65 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -182,6 +182,8 @@
     Window,
 )
 
+# Import ExcelFormatter at runtime since it's used in to_excel method
+from pandas.io.formats.excel import ExcelFormatter
 from pandas.io.formats.format import (
     DataFrameFormatter,
     DataFrameRenderer,
@@ -189,8 +191,8 @@
 from pandas.io.formats.printing import pprint_thing
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
     from collections.abc import (
+        Callable,
         Hashable,
         Iterator,
         Mapping,
@@ -202,15 +204,17 @@
 
     from pandas import (
         DataFrame,
-        ExcelWriter,
         HDFStore,
         Series,
     )
     from pandas.core.indexers.objects import BaseIndexer
     from pandas.core.resample import Resampler
 
+# Import ExcelWriter at runtime since it's used in to_excel method
 import textwrap
 
+from pandas import ExcelWriter
+
 # goal is to be able to define the docs close to function, while still being
 # able to share
 _shared_docs = {**_shared_docs}
@@ -773,6 +777,7 @@ def _set_axis(self, axis: AxisInt, labels: AnyArrayLike | list) -> None:
         """
         labels = ensure_index(labels)
         self._mgr.set_axis(axis, labels)
+
     @final
     @doc(klass=_shared_doc_kwargs["klass"])
     def droplevel(self, level: IndexLabel, axis: Axis = 0) -> Self:
@@ -1514,6 +1519,7 @@ def __bool__(self) -> NoReturn:
             f"The truth value of a {type(self).__name__} is ambiguous. "
             "Use a.empty, a.bool(), a.item(), a.any() or a.all()."
         )
+
     @final
     def abs(self) -> Self:
         """
@@ -2265,7 +2271,7 @@ def to_excel(
 
         Examples
         --------
-        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        >>> df = pd.DataFrame({{"A": [1, 2, 3], "B": [4, 5, 6]}})
         >>> df.to_excel("pandas_simple.xlsx")
         >>> df.to_excel("pandas_simple.xlsx", engine="openpyxl")
         """
@@ -2279,11 +2285,7 @@ def to_excel(
             excel_writer = ExcelWriter(
                 excel_writer,
                 engine=engine,
-                mode=mode,
-                if_sheet_exists=if_sheet_exists,
                 engine_kwargs=engine_kwargs,
-                date_format=date_format,
-                datetime_format=datetime_format,
                 storage_options=storage_options,
             )
 
@@ -5616,6 +5618,7 @@ def f(x) -> bool:
             return self.loc(axis=axis)[values]
         else:
             raise TypeError("Must pass either `items`, `like`, or `regex`")
+
     @final
     def head(self, n: int = 5) -> Self:
         """
@@ -6088,7 +6091,8 @@ def __finalize__(self, other, method: str | None = None, **kwargs) -> Self:
         ----------
         other : the object from which to get the attributes that we are going
             to propagate. If ``other`` has an ``input_objs`` attribute, then
-            this attribute must contain an iterable of objects, each with an ``attrs`` attribute.
+            this attribute must contain an iterable of objects, each with an
+            ``attrs`` attribute.
         method : str, optional
             A passed method name providing context on where ``__finalize__``
             was called.
@@ -9693,6 +9697,7 @@ def align(
         left = left.__finalize__(self)
         right = right.__finalize__(other)
         return left, right
+
     @final
     def _align_frame(
         self,
@@ -12811,6 +12816,8 @@ def last_valid_index(self) -> Hashable:
     The required number of valid values to perform the operation. If fewer than
     ``min_count`` non-NA values are present the result will be NA.
 """
+
+
 def make_doc(name: str, ndim: int) -> str:
     """
     Generate the docstring for a Series/DataFrame reduction.
@@ -13177,4 +13184,4 @@ def make_doc(name: str, ndim: int) -> str:
         examples=examples,
         **kwargs,
     )
-    return docstr
\ No newline at end of file
+    return docstr
diff --git a/pandas/tests/io/excel/test_xlsxwriter.py b/pandas/tests/io/excel/test_xlsxwriter.py
index 62822ae3d7291..2637337e3f0c7 100644
--- a/pandas/tests/io/excel/test_xlsxwriter.py
+++ b/pandas/tests/io/excel/test_xlsxwriter.py
@@ -3,6 +3,7 @@
 
 import pytest
 
+import pandas as pd
 from pandas import DataFrame
 
 from pandas.io.excel import ExcelWriter
@@ -179,4 +180,4 @@ def test_to_excel_autofilter_multiindex_no_merge_xlsxwriter(tmp_excel):
         assert ws.auto_filter is not None
         assert ws.auto_filter.ref is not None
     finally:
-        wb.close()
\ No newline at end of file
+        wb.close()

From 44010db7c642d27988dc25692dd176bfd0b4dab8 Mon Sep 17 00:00:00 2001
From: antznette1 <Ochiezeanthonette@gmail.com>
Date: Wed, 5 Nov 2025 01:03:20 +0100
Subject: [PATCH 5/9] FIX: Move ExcelWriter and ExcelFormatter imports to avoid
 circular import

- Keep ExcelWriter and ExcelFormatter in TYPE_CHECKING for type hints
- Import both at runtime inside to_excel method to avoid circular import
---
 pandas/core/generic.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 60defca0a5c65..400ee8ca5072c 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -182,8 +182,6 @@
     Window,
 )
 
-# Import ExcelFormatter at runtime since it's used in to_excel method
-from pandas.io.formats.excel import ExcelFormatter
 from pandas.io.formats.format import (
     DataFrameFormatter,
     DataFrameRenderer,
@@ -204,17 +202,15 @@
 
     from pandas import (
         DataFrame,
+        ExcelWriter,
         HDFStore,
         Series,
     )
     from pandas.core.indexers.objects import BaseIndexer
     from pandas.core.resample import Resampler
 
-# Import ExcelWriter at runtime since it's used in to_excel method
 import textwrap
 
-from pandas import ExcelWriter
-
 # goal is to be able to define the docs close to function, while still being
 # able to share
 _shared_docs = {**_shared_docs}
@@ -2275,6 +2271,9 @@ def to_excel(
         >>> df.to_excel("pandas_simple.xlsx")
         >>> df.to_excel("pandas_simple.xlsx", engine="openpyxl")
         """
+        # Import ExcelWriter here to avoid circular import
+        from pandas import ExcelWriter
+
         if isinstance(excel_writer, ExcelWriter):
             if engine is not None:
                 raise ValueError(
@@ -2289,6 +2288,9 @@ def to_excel(
                 storage_options=storage_options,
             )
 
+        # Import ExcelFormatter here to avoid circular import
+        from pandas.io.formats.excel import ExcelFormatter
+
         formatter = ExcelFormatter(
             self,
             na_rep=na_rep,

From ea941f6c8db970a041e3394278eb4be58665c8ca Mon Sep 17 00:00:00 2001
From: jbrockmendel <jbrockmendel@gmail.com>
Date: Thu, 6 Nov 2025 15:01:04 -0800
Subject: [PATCH 6/9] REF: inline array_to_datetime64 cases, update tests
 (#63015)

---
 pandas/_libs/tslibs/timedeltas.pyx            | 149 ++++++++----------
 pandas/tests/arithmetic/test_datetime64.py    |   4 +-
 pandas/tests/arithmetic/test_period.py        |  10 +-
 pandas/tests/arithmetic/test_timedelta64.py   |  12 +-
 pandas/tests/frame/test_reductions.py         |   6 +-
 .../tests/indexes/timedeltas/test_formats.py  |   6 +-
 .../tests/indexes/timedeltas/test_setops.py   |   2 +-
 pandas/tests/io/json/test_pandas.py           |   4 +-
 pandas/tests/series/test_arithmetic.py        |   2 +-
 pandas/tests/tools/test_to_timedelta.py       |   8 +-
 10 files changed, 96 insertions(+), 107 deletions(-)

diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 7f90bc5d7da74..2d18a275f26f5 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -333,58 +333,39 @@ cdef convert_to_timedelta64(object ts, str unit):
 
     Handle these types of objects:
         - timedelta/Timedelta
-        - timedelta64
-        - an offset
-        - np.int64 (with unit providing a possible modifier)
-        - None/NaT
 
-    Return an ns based int64
+    Return an timedelta64[ns] object
     """
     # Caller is responsible for checking unit not in ["Y", "y", "M"]
-    if checknull_with_nat_and_na(ts):
-        return np.timedelta64(NPY_NAT, "ns")
-    elif isinstance(ts, _Timedelta):
+    if isinstance(ts, _Timedelta):
         # already in the proper format
         if ts._creso != NPY_FR_ns:
             ts = ts.as_unit("ns").asm8
         else:
             ts = np.timedelta64(ts._value, "ns")
-    elif cnp.is_timedelta64_object(ts):
-        ts = ensure_td64ns(ts)
-    elif is_integer_object(ts):
-        if ts == NPY_NAT:
-            return np.timedelta64(NPY_NAT, "ns")
-        else:
-            ts = _maybe_cast_from_unit(ts, unit)
-    elif is_float_object(ts):
-        ts = _maybe_cast_from_unit(ts, unit)
-    elif isinstance(ts, str):
-        if (len(ts) > 0 and ts[0] == "P") or (len(ts) > 1 and ts[:2] == "-P"):
-            ts = parse_iso_format_string(ts)
-        else:
-            ts = parse_timedelta_string(ts)
-        ts = np.timedelta64(ts, "ns")
-    elif is_tick_object(ts):
-        ts = np.timedelta64(ts.nanos, "ns")
 
-    if PyDelta_Check(ts):
+    elif PyDelta_Check(ts):
         ts = np.timedelta64(delta_to_nanoseconds(ts), "ns")
     elif not cnp.is_timedelta64_object(ts):
         raise TypeError(f"Invalid type for timedelta scalar: {type(ts)}")
     return ts.astype("timedelta64[ns]")
 
 
-cdef _maybe_cast_from_unit(ts, str unit):
+cdef _numeric_to_td64ns(object item, str unit):
     # caller is responsible for checking
     #  assert unit not in ["Y", "y", "M"]
+    #  assert is_integer_object(item) or is_float_object(item)
+    if is_integer_object(item) and item == NPY_NAT:
+        return np.timedelta64(NPY_NAT, "ns")
+
     try:
-        ts = cast_from_unit(ts, unit)
+        item = cast_from_unit(item, unit)
     except OutOfBoundsDatetime as err:
         raise OutOfBoundsTimedelta(
-            f"Cannot cast {ts} from {unit} to 'ns' without overflow."
+            f"Cannot cast {item} from {unit} to 'ns' without overflow."
         ) from err
 
-    ts = np.timedelta64(ts, "ns")
+    ts = np.timedelta64(item, "ns")
     return ts
 
 
@@ -408,10 +389,11 @@ def array_to_timedelta64(
     cdef:
         Py_ssize_t i, n = values.size
         ndarray result = np.empty((<object>values).shape, dtype="m8[ns]")
-        object item
+        object item, td64ns_obj
         int64_t ival
         cnp.broadcast mi = cnp.PyArray_MultiIterNew2(result, values)
         cnp.flatiter it
+        str parsed_unit = parse_timedelta_unit(unit or "ns")
 
     if values.descr.type_num != cnp.NPY_OBJECT:
         # raise here otherwise we segfault below
@@ -431,70 +413,63 @@ def array_to_timedelta64(
                 )
             cnp.PyArray_ITER_NEXT(it)
 
-    # Usually, we have all strings. If so, we hit the fast path.
-    # If this path fails, we try conversion a different way, and
-    # this is where all of the error handling will take place.
-    try:
-        for i in range(n):
-            # Analogous to: item = values[i]
-            item = <object>(<PyObject**>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+    for i in range(n):
+        item = <object>(<PyObject**>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
 
-            ival = _item_to_timedelta64_fastpath(item)
+        try:
+            if checknull_with_nat_and_na(item):
+                ival = NPY_NAT
 
-            # Analogous to: iresult[i] = ival
-            (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = ival
+            elif cnp.is_timedelta64_object(item):
+                td64ns_obj = ensure_td64ns(item)
+                ival = cnp.get_timedelta64_value(td64ns_obj)
 
-            cnp.PyArray_MultiIter_NEXT(mi)
+            elif isinstance(item, _Timedelta):
+                if item._creso != NPY_FR_ns:
+                    ival = item.as_unit("ns")._value
+                else:
+                    ival = item._value
+
+            elif PyDelta_Check(item):
+                # i.e. isinstance(item, timedelta)
+                ival = delta_to_nanoseconds(item)
+
+            elif isinstance(item, str):
+                if (
+                    (len(item) > 0 and item[0] == "P")
+                    or (len(item) > 1 and item[:2] == "-P")
+                ):
+                    ival = parse_iso_format_string(item)
+                else:
+                    ival = parse_timedelta_string(item)
 
-    except (TypeError, ValueError):
-        cnp.PyArray_MultiIter_RESET(mi)
+            elif is_tick_object(item):
+                ival = item.nanos
 
-        parsed_unit = parse_timedelta_unit(unit or "ns")
-        for i in range(n):
-            item = <object>(<PyObject**>cnp.PyArray_MultiIter_DATA(mi, 1))[0]
+            elif is_integer_object(item) or is_float_object(item):
+                td64ns_obj = _numeric_to_td64ns(item, parsed_unit)
+                ival = cnp.get_timedelta64_value(td64ns_obj)
 
-            ival = _item_to_timedelta64(item, parsed_unit, errors)
+            else:
+                raise TypeError(f"Invalid type for timedelta scalar: {type(item)}")
+
+        except ValueError as err:
+            if errors == "coerce":
+                ival = NPY_NAT
+            elif "unit abbreviation w/o a number" in str(err):
+                # re-raise with more pertinent message
+                msg = f"Could not convert '{item}' to NumPy timedelta"
+                raise ValueError(msg) from err
+            else:
+                raise
 
-            (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = ival
+        (<int64_t*>cnp.PyArray_MultiIter_DATA(mi, 0))[0] = ival
 
-            cnp.PyArray_MultiIter_NEXT(mi)
+        cnp.PyArray_MultiIter_NEXT(mi)
 
     return result
 
 
-cdef int64_t _item_to_timedelta64_fastpath(object item) except? -1:
-    """
-    See array_to_timedelta64.
-    """
-    if item is NaT:
-        # we allow this check in the fast-path because NaT is a C-object
-        #  so this is an inexpensive check
-        return NPY_NAT
-    else:
-        return parse_timedelta_string(item)
-
-
-cdef int64_t _item_to_timedelta64(
-    object item,
-    str parsed_unit,
-    str errors
-) except? -1:
-    """
-    See array_to_timedelta64.
-    """
-    try:
-        return cnp.get_timedelta64_value(convert_to_timedelta64(item, parsed_unit))
-    except ValueError as err:
-        if errors == "coerce":
-            return NPY_NAT
-        elif "unit abbreviation w/o a number" in str(err):
-            # re-raise with more pertinent message
-            msg = f"Could not convert '{item}' to NumPy timedelta"
-            raise ValueError(msg) from err
-        else:
-            raise
-
-
 @cython.cpow(True)
 cdef int64_t parse_timedelta_string(str ts) except? -1:
     """
@@ -2154,12 +2129,14 @@ class Timedelta(_Timedelta):
             new_value = delta_to_nanoseconds(value, reso=new_reso)
             return cls._from_value_and_reso(new_value, reso=new_reso)
 
+        elif checknull_with_nat_and_na(value):
+            return NaT
+
         elif is_integer_object(value) or is_float_object(value):
             # unit=None is de-facto 'ns'
             unit = parse_timedelta_unit(unit)
-            value = convert_to_timedelta64(value, unit)
-        elif checknull_with_nat_and_na(value):
-            return NaT
+            value = _numeric_to_td64ns(value, unit)
+
         else:
             raise ValueError(
                 "Value must be Timedelta, string, integer, "
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index 52943f4e10148..b83dc3052fbb3 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -1011,7 +1011,9 @@ def test_dt64arr_sub_timestamp_tzaware(self, box_with_array):
 
         ser = tm.box_expected(ser, box_with_array)
 
-        delta_series = Series([np.timedelta64(0, "D"), np.timedelta64(1, "D")])
+        delta_series = Series(
+            [np.timedelta64(0, "D"), np.timedelta64(1, "D")], dtype="m8[ns]"
+        )
         expected = tm.box_expected(delta_series, box_with_array)
 
         tm.assert_equal(ser - ts, expected)
diff --git a/pandas/tests/arithmetic/test_period.py b/pandas/tests/arithmetic/test_period.py
index 67762e0b89c73..0514bc203bf66 100644
--- a/pandas/tests/arithmetic/test_period.py
+++ b/pandas/tests/arithmetic/test_period.py
@@ -1641,7 +1641,9 @@ def test_pi_sub_period(self):
         result = np.subtract(Period("2012-01", freq="M"), idx)
         tm.assert_index_equal(result, exp)
 
-        exp = TimedeltaIndex([np.nan, np.nan, np.nan, np.nan], name="idx")
+        exp = TimedeltaIndex(
+            [np.nan, np.nan, np.nan, np.nan], name="idx", dtype="m8[ns]"
+        )
         result = idx - Period("NaT", freq="M")
         tm.assert_index_equal(result, exp)
         assert result.freq == exp.freq
@@ -1655,7 +1657,7 @@ def test_pi_sub_pdnat(self):
         idx = PeriodIndex(
             ["2011-01", "2011-02", "NaT", "2011-04"], freq="M", name="idx"
         )
-        exp = TimedeltaIndex([pd.NaT] * 4, name="idx")
+        exp = TimedeltaIndex([pd.NaT] * 4, name="idx", dtype="m8[ns]")
         tm.assert_index_equal(pd.NaT - idx, exp)
         tm.assert_index_equal(idx - pd.NaT, exp)
 
@@ -1674,6 +1676,8 @@ def test_pi_sub_period_nat(self):
         exp = pd.Index([12 * off, pd.NaT, 10 * off, 9 * off], name="idx")
         tm.assert_index_equal(result, exp)
 
-        exp = TimedeltaIndex([np.nan, np.nan, np.nan, np.nan], name="idx")
+        exp = TimedeltaIndex(
+            [np.nan, np.nan, np.nan, np.nan], name="idx", dtype="m8[ns]"
+        )
         tm.assert_index_equal(idx - Period("NaT", freq="M"), exp)
         tm.assert_index_equal(Period("NaT", freq="M") - idx, exp)
diff --git a/pandas/tests/arithmetic/test_timedelta64.py b/pandas/tests/arithmetic/test_timedelta64.py
index 7212b93a7c5b7..9a54386abf281 100644
--- a/pandas/tests/arithmetic/test_timedelta64.py
+++ b/pandas/tests/arithmetic/test_timedelta64.py
@@ -850,7 +850,7 @@ def test_operators_timedelta64(self):
         assert rs.dtype == "timedelta64[ns]"
 
         df = DataFrame({"A": v1})
-        td = Series([timedelta(days=i) for i in range(3)])
+        td = Series([timedelta(days=i) for i in range(3)], dtype="m8[ns]")
         assert td.dtype == "timedelta64[ns]"
 
         # series on the rhs
@@ -875,7 +875,9 @@ def test_operators_timedelta64(self):
 
         # datetimes on rhs
         result = df["A"] - datetime(2001, 1, 1)
-        expected = Series([timedelta(days=4017 + i) for i in range(3)], name="A")
+        expected = Series(
+            [timedelta(days=4017 + i) for i in range(3)], name="A", dtype="m8[ns]"
+        )
         tm.assert_series_equal(result, expected)
         assert result.dtype == "m8[ns]"
 
@@ -1559,7 +1561,7 @@ def test_tdi_rmul_arraylike(self, other, box_with_array):
 
     def test_td64arr_mul_bool_scalar_raises(self, box_with_array):
         # GH#58054
-        ser = Series(np.arange(5) * timedelta(hours=1))
+        ser = Series(np.arange(5) * timedelta(hours=1), dtype="m8[ns]")
         obj = tm.box_expected(ser, box_with_array)
 
         msg = r"Cannot multiply 'timedelta64\[ns\]' by bool"
@@ -1582,7 +1584,7 @@ def test_td64arr_mul_bool_scalar_raises(self, box_with_array):
     )
     def test_td64arr_mul_bool_raises(self, dtype, box_with_array):
         # GH#58054
-        ser = Series(np.arange(5) * timedelta(hours=1))
+        ser = Series(np.arange(5) * timedelta(hours=1), dtype="m8[ns]")
         obj = tm.box_expected(ser, box_with_array)
 
         other = Series(np.arange(5) < 0.5, dtype=dtype)
@@ -1611,7 +1613,7 @@ def test_td64arr_mul_bool_raises(self, dtype, box_with_array):
         ],
     )
     def test_td64arr_mul_masked(self, dtype, box_with_array):
-        ser = Series(np.arange(5) * timedelta(hours=1))
+        ser = Series(np.arange(5) * timedelta(hours=1), dtype="m8[ns]")
         obj = tm.box_expected(ser, box_with_array)
 
         other = Series(np.arange(5), dtype=dtype)
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index 7c4ce4c67f13d..4d235587c2407 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -747,12 +747,14 @@ def test_operators_timedelta64(self):
 
         # works when only those columns are selected
         result = mixed[["A", "B"]].min(axis=1)
-        expected = Series([timedelta(days=-1)] * 3)
+        expected = Series([timedelta(days=-1)] * 3, dtype="m8[ns]")
         tm.assert_series_equal(result, expected)
 
         result = mixed[["A", "B"]].min()
         expected = Series(
-            [timedelta(seconds=5 * 60 + 5), timedelta(days=-1)], index=["A", "B"]
+            [timedelta(seconds=5 * 60 + 5), timedelta(days=-1)],
+            index=["A", "B"],
+            dtype="m8[ns]",
         )
         tm.assert_series_equal(result, expected)
 
diff --git a/pandas/tests/indexes/timedeltas/test_formats.py b/pandas/tests/indexes/timedeltas/test_formats.py
index 607336060cbbc..b1daa0c517570 100644
--- a/pandas/tests/indexes/timedeltas/test_formats.py
+++ b/pandas/tests/indexes/timedeltas/test_formats.py
@@ -22,7 +22,7 @@ def test_repr_round_days_non_nano(self):
 
     @pytest.mark.parametrize("method", ["__repr__", "__str__"])
     def test_representation(self, method):
-        idx1 = TimedeltaIndex([], freq="D")
+        idx1 = TimedeltaIndex([], freq="D", dtype="m8[ns]")
         idx2 = TimedeltaIndex(["1 days"], freq="D")
         idx3 = TimedeltaIndex(["1 days", "2 days"], freq="D")
         idx4 = TimedeltaIndex(["1 days", "2 days", "3 days"], freq="D")
@@ -53,7 +53,7 @@ def test_representation(self, method):
 
     # TODO: this is a Series.__repr__ test
     def test_representation_to_series(self):
-        idx1 = TimedeltaIndex([], freq="D")
+        idx1 = TimedeltaIndex([], freq="D", dtype="m8[ns]")
         idx2 = TimedeltaIndex(["1 days"], freq="D")
         idx3 = TimedeltaIndex(["1 days", "2 days"], freq="D")
         idx4 = TimedeltaIndex(["1 days", "2 days", "3 days"], freq="D")
@@ -83,7 +83,7 @@ def test_representation_to_series(self):
 
     def test_summary(self):
         # GH#9116
-        idx1 = TimedeltaIndex([], freq="D")
+        idx1 = TimedeltaIndex([], freq="D", dtype="m8[ns]")
         idx2 = TimedeltaIndex(["1 days"], freq="D")
         idx3 = TimedeltaIndex(["1 days", "2 days"], freq="D")
         idx4 = TimedeltaIndex(["1 days", "2 days", "3 days"], freq="D")
diff --git a/pandas/tests/indexes/timedeltas/test_setops.py b/pandas/tests/indexes/timedeltas/test_setops.py
index 3ab3c3e1c8633..951b8346ac9e6 100644
--- a/pandas/tests/indexes/timedeltas/test_setops.py
+++ b/pandas/tests/indexes/timedeltas/test_setops.py
@@ -160,7 +160,7 @@ def test_zero_length_input_index(self, sort):
             # if no overlap exists return empty index
             (
                 timedelta_range("1 day", periods=10, freq="h", name="idx")[5:],
-                TimedeltaIndex([], freq="h", name="idx"),
+                TimedeltaIndex([], freq="h", name="idx", dtype="m8[ns]"),
             ),
         ],
     )
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index d67e725233127..9c93be0937e91 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -1131,7 +1131,7 @@ def test_url(self, field, dtype, httpserver):
     def test_timedelta(self):
         converter = lambda x: pd.to_timedelta(x, unit="ms")
 
-        ser = Series([timedelta(23), timedelta(seconds=5)])
+        ser = Series([timedelta(23), timedelta(seconds=5)], dtype="m8[ns]")
         assert ser.dtype == "timedelta64[ns]"
 
         msg = (
@@ -1148,7 +1148,7 @@ def test_timedelta(self):
             result = read_json(StringIO(ser.to_json()), typ="series").apply(converter)
         tm.assert_series_equal(result, ser)
 
-        frame = DataFrame([timedelta(23), timedelta(seconds=5)])
+        frame = DataFrame([timedelta(23), timedelta(seconds=5)], dtype="m8[ns]")
         assert frame[0].dtype == "timedelta64[ns]"
 
         with tm.assert_produces_warning(Pandas4Warning, match=msg):
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index a9ed61e2c40cb..488eb99f81ef5 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -307,7 +307,7 @@ def test_sub_datetimelike_align(self):
         dt.iloc[2] = np.nan
         dt2 = dt[::-1]
 
-        expected = Series([timedelta(0), timedelta(0), pd.NaT])
+        expected = Series([timedelta(0), timedelta(0), pd.NaT], dtype="m8[ns]")
         # name is reset
         result = dt2 - dt
         tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/tools/test_to_timedelta.py b/pandas/tests/tools/test_to_timedelta.py
index 08ad7b7fb1b93..9d5866ef97017 100644
--- a/pandas/tests/tools/test_to_timedelta.py
+++ b/pandas/tests/tools/test_to_timedelta.py
@@ -62,7 +62,9 @@ def test_to_timedelta_same_np_timedelta64(self):
 
     def test_to_timedelta_series(self):
         # Series
-        expected = Series([timedelta(days=1), timedelta(days=1, seconds=1)])
+        expected = Series(
+            [timedelta(days=1), timedelta(days=1, seconds=1)], dtype="m8[ns]"
+        )
 
         msg = "'d' is deprecated and will be removed in a future version."
         with tm.assert_produces_warning(Pandas4Warning, match=msg):
@@ -185,7 +187,7 @@ def test_unambiguous_timedelta_values(self, val, errors):
 
     def test_to_timedelta_via_apply(self):
         # GH 5458
-        expected = Series([np.timedelta64(1, "s")])
+        expected = Series([np.timedelta64(1, "s")], dtype="m8[ns]")
         result = Series(["00:00:01"]).apply(to_timedelta)
         tm.assert_series_equal(result, expected)
 
@@ -247,7 +249,7 @@ def test_to_timedelta_coerce_strings_unit(self):
     )
     def test_to_timedelta_nullable_int64_dtype(self, expected_val, result_val):
         # GH 35574
-        expected = Series([timedelta(days=1), expected_val])
+        expected = Series([timedelta(days=1), expected_val], dtype="m8[ns]")
         result = to_timedelta(Series([1, result_val], dtype="Int64"), unit="days")
 
         tm.assert_series_equal(result, expected)

From dfba03592deb351c48c13faf222ea911dd5761c2 Mon Sep 17 00:00:00 2001
From: antznette1 <Ochiezeanthonette@gmail.com>
Date: Fri, 7 Nov 2025 01:18:43 +0100
Subject: [PATCH 7/9] TST: narrow PR to tests-only; revert engine and unrelated
 test changes

---
 pandas/core/generic.py                   | 188 ++++++++++++-----------
 pandas/io/excel/_base.py                 |   3 -
 pandas/io/excel/_odswriter.py            |   7 -
 pandas/io/excel/_openpyxl.py             |  31 +---
 pandas/io/excel/_xlsxwriter.py           |  29 +---
 pandas/io/formats/excel.py               |   2 -
 pandas/tests/io/excel/test_odswriter.py  |  10 --
 pandas/tests/io/excel/test_openpyxl.py   |  10 ++
 pandas/tests/io/excel/test_xlsxwriter.py |  10 ++
 9 files changed, 123 insertions(+), 167 deletions(-)

diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 400ee8ca5072c..1385d48e0bb4a 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -189,8 +189,8 @@
 from pandas.io.formats.printing import pprint_thing
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
     from collections.abc import (
-        Callable,
         Hashable,
         Iterator,
         Mapping,
@@ -2180,128 +2180,139 @@ def to_excel(
         freeze_panes: tuple[int, int] | None = None,
         storage_options: StorageOptions | None = None,
         engine_kwargs: dict[str, Any] | None = None,
-        autofilter: bool = False,
     ) -> None:
         """
-        Write object to an Excel sheet.
+        Write {klass} to an Excel sheet.
 
-        To write a single object to an Excel .xlsx file it is only necessary
-        to specify a target file name.
+        To write a single {klass} to an Excel .xlsx file it is only necessary to
+        specify a target file name. To write to multiple sheets it is necessary to
+        create an `ExcelWriter` object with a target file name, and specify a sheet
+        in the file to write to.
 
-        .. code-block:: python
-
-            df.to_excel("path_to_file.xlsx")
-
-        To write to different sheets of the same .xlsx file it is necessary to
-        create an `ExcelWriter` object with a target file name,
-        and specify a sheet in the file to write to.
-
-        .. code-block:: python
-
-            with pd.ExcelWriter("path_to_file.xlsx") as writer:
-                df1.to_excel(writer, sheet_name="Sheet_name_1")
-                df2.to_excel(writer, sheet_name="Sheet_name_2")
-
-        When using `ExcelWriter`, note that the objects are not written until the
-        `ExcelWriter` object is closed.
+        Multiple sheets may be written to by specifying unique `sheet_name`.
+        With all data written to the file it is necessary to save the changes.
+        Note that creating an `ExcelWriter` object with a file name that already
+        exists will result in the contents of the existing file being erased.
 
         Parameters
         ----------
-        excel_writer : string, path object or ExcelWriter object
-            File path or existing ExcelWriter
-            If a string is passed, a new ExcelWriter object is created.
+        excel_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.
         na_rep : str, default ''
-            Missing data representation
-        float_format : str, default None
-            Format string for floating point numbers
-        columns : sequence, optional
-            Columns to write
+            Missing data representation.
+        float_format : str, optional
+            Format string for floating point numbers. For example
+            ``float_format="%.2f"`` will format 0.1234 to 0.12.
+        columns : sequence or list of str, optional
+            Columns to write.
         header : bool or list of str, default True
-            Write out the column names. If a list of string is given
-            it is assumed to be aliases for the column names
+            Write out the column names. If a list of string is given it is
+            assumed to be aliases for the column names.
         index : bool, default True
-            Write row names (index)
-        index_label : str or sequence, default None
-            Column label for index column(s) if desired. If None is given, and
+            Write row names (index).
+        index_label : str or sequence, optional
+            Column label for index column(s) if desired. If not specified, and
             `header` and `index` are True, then the index names are used. A
             sequence should be given if the DataFrame uses MultiIndex.
         startrow : int, default 0
             Upper left cell row to dump data frame.
-            Per default (0) header is written, too.
         startcol : int, default 0
             Upper left cell column to dump data frame.
         engine : str, optional
-            Write engine to use, 'openpyxl' or 'xlsxwriter'.
-            Defaults to 'xlsxwriter'.
-        merge_cells : bool, default True
-            Write MultiIndex and Hierarchical Rows as merged cells.
-            The indices corresponding to each row will be combined and
-            presented as a single cell.
+            Write engine to use, 'openpyxl' or 'xlsxwriter'. You can also set this
+            via the options ``io.excel.xlsx.writer`` or
+            ``io.excel.xlsm.writer``.
+
+        merge_cells : bool or 'columns', default False
+            If True, write MultiIndex index and columns as merged cells.
+            If 'columns', merge MultiIndex column cells only.
+        {encoding_parameter}
         inf_rep : str, default 'inf'
-            Representation for infinity (there is no native Numpy representation
-            for infinity in integer dtypes)
-        freeze_panes : tuple of int (length 2), default None
-            First rows to freeze panes on. Only applicable when `freeze_panes`
-            is passed as a tuple.
-        storage_options : dict, optional
-            Extra options that make sense for a particular storage connection,
-            e.g. host, port, username, password, etc., if using a URL that
-            requires authentication.
-        engine_kwargs : dict, optional
-            Arbitrary keyword arguments passed to excel engine.
-        autofilter : bool, default False
-            Whether to apply autofilter to the header row.
+            Representation for infinity (there is no native representation for
+            infinity in Excel).
+        {verbose_parameter}
+        freeze_panes : tuple of int (length 2), optional
+            Specifies the one-based bottommost row and rightmost column that
+            is to be frozen.
+        {storage_options}
 
+            .. versionadded:: {storage_options_versionadded}
+        {extra_parameters}
         See Also
         --------
-        read_excel : Read from an Excel file into a DataFrame.
-        ExcelFile : Class for parsing tabular excel files.
+        to_csv : Write DataFrame to a comma-separated values (csv) file.
         ExcelWriter : Class for writing DataFrame objects into excel sheets.
+        read_excel : Read an Excel file into a pandas DataFrame.
+        read_csv : Read a comma-separated values (csv) file into DataFrame.
+        io.formats.style.Styler.to_excel : Add styles to Excel sheet.
 
         Notes
         -----
-        The `engine` keyword is not supported when `excel_writer` is an
-        existing `ExcelWriter`.
+        For compatibility with :meth:`~DataFrame.to_csv`,
+        to_excel serializes lists and dicts to strings before writing.
+
+        Once a workbook has been saved it is not possible to write further
+        data without rewriting the whole workbook.
+
+        pandas will check the number of rows, columns,
+        and cell character count does not exceed Excel's limitations.
+        All other limitations must be checked by the user.
 
         Examples
         --------
-        >>> df = pd.DataFrame({{"A": [1, 2, 3], "B": [4, 5, 6]}})
-        >>> df.to_excel("pandas_simple.xlsx")
-        >>> df.to_excel("pandas_simple.xlsx", engine="openpyxl")
+
+        Create, write to and save a workbook:
+
+        >>> df1 = pd.DataFrame(
+        ...     [["a", "b"], ["c", "d"]],
+        ...     index=["row 1", "row 2"],
+        ...     columns=["col 1", "col 2"],
+        ... )
+        >>> df1.to_excel("output.xlsx")  # doctest: +SKIP
+
+        To specify the sheet name:
+
+        >>> df1.to_excel("output.xlsx", sheet_name="Sheet_name_1")  # doctest: +SKIP
+
+        If you wish to write to more than one sheet in the workbook, it is
+        necessary to specify an ExcelWriter object:
+
+        >>> df2 = df1.copy()
+        >>> with pd.ExcelWriter("output.xlsx") as writer:  # doctest: +SKIP
+        ...     df1.to_excel(writer, sheet_name="Sheet_name_1")
+        ...     df2.to_excel(writer, sheet_name="Sheet_name_2")
+
+        ExcelWriter can also be used to append to an existing Excel file:
+
+        >>> with pd.ExcelWriter("output.xlsx", mode="a") as writer:  # doctest: +SKIP
+        ...     df1.to_excel(writer, sheet_name="Sheet_name_3")
+
+        To set the library that is used to write the Excel file,
+        you can pass the `engine` keyword (the default engine is
+        automatically chosen depending on the file extension):
+
+        >>> df1.to_excel("output1.xlsx", engine="xlsxwriter")  # doctest: +SKIP
         """
-        # Import ExcelWriter here to avoid circular import
-        from pandas import ExcelWriter
+        if engine_kwargs is None:
+            engine_kwargs = {}
 
-        if isinstance(excel_writer, ExcelWriter):
-            if engine is not None:
-                raise ValueError(
-                    "engine should not be specified when passing an ExcelWriter"
-                )
-            engine = excel_writer.engine
-        else:
-            excel_writer = ExcelWriter(
-                excel_writer,
-                engine=engine,
-                engine_kwargs=engine_kwargs,
-                storage_options=storage_options,
-            )
+        df = self if isinstance(self, ABCDataFrame) else self.to_frame()
 
-        # Import ExcelFormatter here to avoid circular import
         from pandas.io.formats.excel import ExcelFormatter
 
         formatter = ExcelFormatter(
-            self,
+            df,
             na_rep=na_rep,
-            float_format=float_format,
-            columns=columns,
+            cols=columns,
             header=header,
+            float_format=float_format,
             index=index,
             index_label=index_label,
+            merge_cells=merge_cells,
             inf_rep=inf_rep,
         )
-
         formatter.write(
             excel_writer,
             sheet_name=sheet_name,
@@ -2311,13 +2322,8 @@ def to_excel(
             engine=engine,
             storage_options=storage_options,
             engine_kwargs=engine_kwargs,
-            autofilter=autofilter,
         )
 
-        if not isinstance(excel_writer, ExcelWriter):
-            # we need to close the writer if we created it
-            excel_writer.close()
-
     @final
     @doc(
         storage_options=_shared_docs["storage_options"],
@@ -4845,6 +4851,7 @@ def sort_values(
         ignore_index: bool = ...,
         key: ValueKeyFunc = ...,
     ) -> Self: ...
+
     @overload
     def sort_values(
         self,
@@ -9607,10 +9614,10 @@ def align(
         1  1  2  3  4
         2  6  7  8  9
         >>> other
-            A    B    C    D   E
-        2   10   20   30   40 NaN
-        3   60   70   80   90 NaN
-        4  600  700  800  900 NaN
+            A    B    C    D
+        2   10   20   30   40
+        3   60   70   80   90
+        4  600  700  800  900
 
         Align on columns:
 
@@ -12037,6 +12044,7 @@ def last_valid_index(self) -> Hashable:
 {see_also}\
 {examples}
 """
+
 _sum_prod_doc = """
 {desc}
 
diff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py
index becc9380b9cf6..d1ae59e0e5866 100644
--- a/pandas/io/excel/_base.py
+++ b/pandas/io/excel/_base.py
@@ -1209,7 +1209,6 @@ def _write_cells(
         startrow: int = 0,
         startcol: int = 0,
         freeze_panes: tuple[int, int] | None = None,
-        autofilter: bool = False,
     ) -> None:
         """
         Write given formatted cells into Excel an excel sheet
@@ -1224,8 +1223,6 @@ def _write_cells(
         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
-        autofilter : bool, default False
-            If True, apply an autofilter to the header row over the written data range.
         """
         raise NotImplementedError
 
diff --git a/pandas/io/excel/_odswriter.py b/pandas/io/excel/_odswriter.py
index dd5112432ae69..e9a06076f3aff 100644
--- a/pandas/io/excel/_odswriter.py
+++ b/pandas/io/excel/_odswriter.py
@@ -99,17 +99,10 @@ def _write_cells(
         startrow: int = 0,
         startcol: int = 0,
         freeze_panes: tuple[int, int] | None = None,
-        autofilter: bool = False,
     ) -> None:
         """
         Write the frame cells using odf
         """
-        if autofilter:
-            raise NotImplementedError(
-                "Autofilter is not supported with the 'odf' engine. "
-                "Please use 'openpyxl' or 'xlsxwriter' engine instead."
-            )
-
         from odf.table import (
             Table,
             TableCell,
diff --git a/pandas/io/excel/_openpyxl.py b/pandas/io/excel/_openpyxl.py
index 6376bd3bdf2d8..867d11583dcc0 100644
--- a/pandas/io/excel/_openpyxl.py
+++ b/pandas/io/excel/_openpyxl.py
@@ -449,7 +449,6 @@ def _write_cells(
         startrow: int = 0,
         startcol: int = 0,
         freeze_panes: tuple[int, int] | None = None,
-        autofilter: bool = False,
     ) -> None:
         # Write the frame cells using openpyxl.
         sheet_name = self._get_sheet_name(sheet_name)
@@ -487,11 +486,6 @@ def _write_cells(
                 row=freeze_panes[0] + 1, column=freeze_panes[1] + 1
             )
 
-        min_r = None
-        min_c = None
-        max_r = None
-        max_c = None
-
         for cell in cells:
             xcell = wks.cell(
                 row=startrow + cell.row + 1, column=startcol + cell.col + 1
@@ -512,23 +506,10 @@ def _write_cells(
                 for k, v in style_kwargs.items():
                     setattr(xcell, k, v)
 
-            abs_row = startrow + cell.row + 1
-            abs_col = startcol + cell.col + 1
-
-            # track bounds (1-based for openpyxl)
-            if min_r is None or abs_row < min_r:
-                min_r = abs_row
-            if min_c is None or abs_col < min_c:
-                min_c = abs_col
-            if max_r is None or abs_row > max_r:
-                max_r = abs_row
-            if max_c is None or abs_col > max_c:
-                max_c = abs_col
-
             if cell.mergestart is not None and cell.mergeend is not None:
                 wks.merge_cells(
-                    start_row=abs_row,
-                    start_column=abs_col,
+                    start_row=startrow + cell.row + 1,
+                    start_column=startcol + cell.col + 1,
                     end_column=startcol + cell.mergeend + 1,
                     end_row=startrow + cell.mergestart + 1,
                 )
@@ -551,14 +532,6 @@ def _write_cells(
                             for k, v in style_kwargs.items():
                                 setattr(xcell, k, v)
 
-        if autofilter and min_r is not None and min_c is not None and max_r is not None and max_c is not None:
-            # Convert numeric bounds to Excel-style range e.g. A1:D10
-            from openpyxl.utils import get_column_letter
-
-            start_ref = f"{get_column_letter(min_c)}{min_r}"
-            end_ref = f"{get_column_letter(max_c)}{max_r}"
-            wks.auto_filter.ref = f"{start_ref}:{end_ref}"
-
 
 class OpenpyxlReader(BaseExcelReader["Workbook"]):
     @doc(storage_options=_shared_docs["storage_options"])
diff --git a/pandas/io/excel/_xlsxwriter.py b/pandas/io/excel/_xlsxwriter.py
index d9df2595cb32c..4a7b8eee2bfce 100644
--- a/pandas/io/excel/_xlsxwriter.py
+++ b/pandas/io/excel/_xlsxwriter.py
@@ -245,7 +245,6 @@ def _write_cells(
         startrow: int = 0,
         startcol: int = 0,
         freeze_panes: tuple[int, int] | None = None,
-        autofilter: bool = False,
     ) -> None:
         # Write the frame cells using xlsxwriter.
         sheet_name = self._get_sheet_name(sheet_name)
@@ -259,11 +258,6 @@ def _write_cells(
         if validate_freeze_panes(freeze_panes):
             wks.freeze_panes(*(freeze_panes))
 
-        min_r = None
-        min_c = None
-        max_r = None
-        max_c = None
-
         for cell in cells:
             val, fmt = self._value_with_fmt(cell.val)
 
@@ -277,31 +271,14 @@ def _write_cells(
                 style = self.book.add_format(_XlsxStyler.convert(cell.style, fmt))
                 style_dict[stylekey] = style
 
-            abs_row = startrow + cell.row
-            abs_col = startcol + cell.col
-
-            # track bounds
-            if min_r is None or abs_row < min_r:
-                min_r = abs_row
-            if min_c is None or abs_col < min_c:
-                min_c = abs_col
-            if max_r is None or abs_row > max_r:
-                max_r = abs_row
-            if max_c is None or abs_col > max_c:
-                max_c = abs_col
-
             if cell.mergestart is not None and cell.mergeend is not None:
                 wks.merge_range(
-                    abs_row,
-                    abs_col,
+                    startrow + cell.row,
+                    startcol + cell.col,
                     startrow + cell.mergestart,
                     startcol + cell.mergeend,
                     val,
                     style,
                 )
             else:
-                wks.write(abs_row, abs_col, val, style)
-
-        if autofilter and min_r is not None and min_c is not None and max_r is not None and max_c is not None:
-            # Apply autofilter over the used range. xlsxwriter uses 0-based indices.
-            wks.autofilter(min_r, min_c, max_r, max_c)
+                wks.write(startrow + cell.row, startcol + cell.col, val, style)
diff --git a/pandas/io/formats/excel.py b/pandas/io/formats/excel.py
index f8978feb4a2a6..d4d47253a5f82 100644
--- a/pandas/io/formats/excel.py
+++ b/pandas/io/formats/excel.py
@@ -884,7 +884,6 @@ def write(
         engine: str | None = None,
         storage_options: StorageOptions | None = None,
         engine_kwargs: dict | None = None,
-        autofilter: bool = False,
     ) -> None:
         """
         writer : path-like, file-like, or ExcelWriter object
@@ -939,7 +938,6 @@ def write(
                 startrow=startrow,
                 startcol=startcol,
                 freeze_panes=freeze_panes,
-                autofilter=autofilter,
             )
         finally:
             # make sure to close opened file handles
diff --git a/pandas/tests/io/excel/test_odswriter.py b/pandas/tests/io/excel/test_odswriter.py
index 502c04f9781cc..7843bb59f97cf 100644
--- a/pandas/tests/io/excel/test_odswriter.py
+++ b/pandas/tests/io/excel/test_odswriter.py
@@ -104,13 +104,3 @@ def test_cell_value_type(
         cell = sheet_cells[0]
         assert cell.attributes.get((OFFICENS, "value-type")) == cell_value_type
         assert cell.attributes.get((OFFICENS, cell_value_attribute)) == cell_value
-
-
-def test_to_excel_autofilter_odfpy_raises(tmp_excel):
-    # Test that autofilter=True raises NotImplementedError with odfpy engine
-    from pandas import DataFrame
-
-    df = DataFrame({"A": [1, 2], "B": [3, 4]})
-    msg = "Autofilter is not supported with the 'odf' engine"
-    with pytest.raises(NotImplementedError, match=msg):
-        df.to_excel(tmp_excel, engine="odf", autofilter=True)
\ No newline at end of file
diff --git a/pandas/tests/io/excel/test_openpyxl.py b/pandas/tests/io/excel/test_openpyxl.py
index 1fb6fdae3b5de..ef793ad08077b 100644
--- a/pandas/tests/io/excel/test_openpyxl.py
+++ b/pandas/tests/io/excel/test_openpyxl.py
@@ -18,6 +18,12 @@
 
 openpyxl = pytest.importorskip("openpyxl")
 
+# xfail marker for pending autofilter feature; see #62994
+xfail_autofilter = pytest.mark.xfail(
+    reason="Excel header autofilter not yet implemented on main; see #62994",
+    strict=False,
+)
+
 
 @pytest.fixture
 def ext():
@@ -155,6 +161,7 @@ def test_engine_kwargs_append_data_only(tmp_excel, data_only, expected):
     )
 
 
+@xfail_autofilter
 def test_to_excel_autofilter_openpyxl(tmp_excel):
     # Ensure that writing with autofilter=True sets auto_filter.ref
     df = DataFrame({"A": [1, 2], "B": [3, 4]})
@@ -170,6 +177,7 @@ def test_to_excel_autofilter_openpyxl(tmp_excel):
         assert "B" in ws.auto_filter.ref
 
 
+@xfail_autofilter
 def test_to_excel_autofilter_startrow_startcol_openpyxl(tmp_excel):
     # Test autofilter with nonzero startrow and startcol
     df = DataFrame({"A": [1, 2], "B": [3, 4]})
@@ -191,6 +199,7 @@ def test_to_excel_autofilter_startrow_startcol_openpyxl(tmp_excel):
         assert "3" in ws.auto_filter.ref
 
 
+@xfail_autofilter
 def test_to_excel_autofilter_multiindex_merge_cells_openpyxl(tmp_excel):
     # Test autofilter with MultiIndex columns and merge_cells=True
     df = DataFrame(
@@ -213,6 +222,7 @@ def test_to_excel_autofilter_multiindex_merge_cells_openpyxl(tmp_excel):
         assert ws.auto_filter.ref is not None
 
 
+@xfail_autofilter
 def test_to_excel_autofilter_multiindex_no_merge_openpyxl(tmp_excel):
     # Test autofilter with MultiIndex columns and merge_cells=False
     df = DataFrame(
diff --git a/pandas/tests/io/excel/test_xlsxwriter.py b/pandas/tests/io/excel/test_xlsxwriter.py
index 2637337e3f0c7..510c604ce4eaf 100644
--- a/pandas/tests/io/excel/test_xlsxwriter.py
+++ b/pandas/tests/io/excel/test_xlsxwriter.py
@@ -10,6 +10,12 @@
 
 xlsxwriter = pytest.importorskip("xlsxwriter")
 
+# xfail marker for pending autofilter feature; see #62994
+xfail_autofilter = pytest.mark.xfail(
+    reason="Excel header autofilter not yet implemented on main; see #62994",
+    strict=False,
+)
+
 
 @pytest.fixture
 def ext():
@@ -87,6 +93,7 @@ def test_book_and_sheets_consistent(tmp_excel):
         assert writer.sheets == {"test_name": sheet}
 
 
+@xfail_autofilter
 def test_to_excel_autofilter_xlsxwriter(tmp_excel):
     openpyxl = pytest.importorskip("openpyxl")
 
@@ -106,6 +113,7 @@ def test_to_excel_autofilter_xlsxwriter(tmp_excel):
         wb.close()
 
 
+@xfail_autofilter
 def test_to_excel_autofilter_startrow_startcol_xlsxwriter(tmp_excel):
     openpyxl = pytest.importorskip("openpyxl")
 
@@ -131,6 +139,7 @@ def test_to_excel_autofilter_startrow_startcol_xlsxwriter(tmp_excel):
         wb.close()
 
 
+@xfail_autofilter
 def test_to_excel_autofilter_multiindex_merge_cells_xlsxwriter(tmp_excel):
     openpyxl = pytest.importorskip("openpyxl")
 
@@ -157,6 +166,7 @@ def test_to_excel_autofilter_multiindex_merge_cells_xlsxwriter(tmp_excel):
         wb.close()
 
 
+@xfail_autofilter
 def test_to_excel_autofilter_multiindex_no_merge_xlsxwriter(tmp_excel):
     openpyxl = pytest.importorskip("openpyxl")
 

From 21b7cf1912439be37c7ce588e3cec33c36debb31 Mon Sep 17 00:00:00 2001
From: antznette1 <Ochiezeanthonette@gmail.com>
Date: Sun, 9 Nov 2025 03:31:48 +0100
Subject: [PATCH 8/9] TST: xfail sparse roundtrip tests for Parquet and Feather
 (preserve_sparse flag)

---
 pandas/tests/io/test_feather_sparse.py | 35 ++++++++++++++++++++++++++
 pandas/tests/io/test_parquet_sparse.py | 35 ++++++++++++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 pandas/tests/io/test_feather_sparse.py
 create mode 100644 pandas/tests/io/test_parquet_sparse.py

diff --git a/pandas/tests/io/test_feather_sparse.py b/pandas/tests/io/test_feather_sparse.py
new file mode 100644
index 0000000000000..f430f2426050b
--- /dev/null
+++ b/pandas/tests/io/test_feather_sparse.py
@@ -0,0 +1,35 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+
+pa = pytest.importorskip("pyarrow")
+
+xfail_sparse = pytest.mark.xfail(
+    reason="pending implementation of preserve_sparse for Feather",
+    strict=False,
+)
+
+
+@xfail_sparse
+@pytest.mark.parametrize(
+    "subtype, fill_value, data",
+    [
+        ("int64", 0, [0, 0, 3, 0, 5]),
+        ("float64", 0.0, [0.0, 0.0, 1.5, 0.0, 2.5]),
+        ("boolean", False, [False, False, True, False, True]),
+    ],
+)
+def test_feather_sparse_roundtrip(tmp_path, subtype, fill_value, data):
+    path = tmp_path / "out.feather"
+    s = pd.Series(pd.arrays.SparseArray(data, fill_value=fill_value))
+    df = pd.DataFrame({"s": s, "x": np.arange(len(s))})
+
+    df.to_feather(path, preserve_sparse=True)
+    df2 = pd.read_feather(path, preserve_sparse=True)
+
+    assert isinstance(df2["s"].dtype, pd.SparseDtype)
+    assert df2["s"].dtype.fill_value == fill_value
+    pd.testing.assert_series_equal(
+        df2["s"].sparse.to_dense(), s.sparse.to_dense(), check_dtype=False
+    )
diff --git a/pandas/tests/io/test_parquet_sparse.py b/pandas/tests/io/test_parquet_sparse.py
new file mode 100644
index 0000000000000..e60881ec88a81
--- /dev/null
+++ b/pandas/tests/io/test_parquet_sparse.py
@@ -0,0 +1,35 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+
+pa = pytest.importorskip("pyarrow")
+
+xfail_sparse = pytest.mark.xfail(
+    reason="pending implementation of preserve_sparse for Parquet",
+    strict=False,
+)
+
+
+@xfail_sparse
+@pytest.mark.parametrize(
+    "subtype, fill_value, data",
+    [
+        ("int64", 0, [0, 0, 3, 0, 5]),
+        ("float64", 0.0, [0.0, 0.0, 1.5, 0.0, 2.5]),
+        ("boolean", False, [False, False, True, False, True]),
+    ],
+)
+def test_parquet_sparse_roundtrip(tmp_path, subtype, fill_value, data):
+    path = tmp_path / "out.parquet"
+    s = pd.Series(pd.arrays.SparseArray(data, fill_value=fill_value))
+    df = pd.DataFrame({"s": s, "x": np.arange(len(s))})
+
+    df.to_parquet(path, preserve_sparse=True)
+    df2 = pd.read_parquet(path, preserve_sparse=True)
+
+    assert isinstance(df2["s"].dtype, pd.SparseDtype)
+    assert df2["s"].dtype.fill_value == fill_value
+    pd.testing.assert_series_equal(
+        df2["s"].sparse.to_dense(), s.sparse.to_dense(), check_dtype=False
+    )

From 20a06a6e9718c02da77d38b363033358ed1254cc Mon Sep 17 00:00:00 2001
From: antznette1 <Ochiezeanthonette@gmail.com>
Date: Sun, 9 Nov 2025 04:12:35 +0100
Subject: [PATCH 9/9] ENH: plumb no-op preserve_sparse flag in Parquet/Feather
 IO; TST: use tm.assert_series_equal in sparse IO tests

---
 pandas/io/feather_format.py            | 8 ++++++++
 pandas/io/parquet.py                   | 5 +++++
 pandas/tests/io/test_feather_sparse.py | 3 ++-
 pandas/tests/io/test_parquet_sparse.py | 3 ++-
 4 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/pandas/io/feather_format.py b/pandas/io/feather_format.py
index 19f1e41f5b22f..f7a306bd49b53 100644
--- a/pandas/io/feather_format.py
+++ b/pandas/io/feather_format.py
@@ -65,6 +65,10 @@ def to_feather(
     if not isinstance(df, DataFrame):
         raise ValueError("feather only support IO with DataFrames")
 
+    # accept and ignore optional no-op flag for draft feature
+    if "preserve_sparse" in kwargs:
+        kwargs.pop("preserve_sparse")
+
     with get_handle(
         path, "wb", storage_options=storage_options, is_text=False
     ) as handles:
@@ -79,6 +83,7 @@ def read_feather(
     use_threads: bool = True,
     storage_options: StorageOptions | None = None,
     dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
+    preserve_sparse: bool = False,
 ) -> DataFrame:
     """
     Load a feather-format object from the file path.
@@ -141,6 +146,9 @@ def read_feather(
 
     check_dtype_backend(dtype_backend)
 
+    # accept and ignore optional no-op flag for draft feature
+    _ = preserve_sparse
+
     with get_handle(
         path, "rb", storage_options=storage_options, is_text=False
     ) as handles:
diff --git a/pandas/io/parquet.py b/pandas/io/parquet.py
index 878f51a2b9eac..12b7f5ebd2dfc 100644
--- a/pandas/io/parquet.py
+++ b/pandas/io/parquet.py
@@ -481,6 +481,11 @@ def to_parquet(
     """
     if isinstance(partition_cols, str):
         partition_cols = [partition_cols]
+    # accept and ignore optional no-op flag for draft feature
+    # (do not forward to engines)
+    if "preserve_sparse" in kwargs:
+        kwargs.pop("preserve_sparse")
+
     impl = get_engine(engine)
 
     path_or_buf: FilePath | WriteBuffer[bytes] = io.BytesIO() if path is None else path
diff --git a/pandas/tests/io/test_feather_sparse.py b/pandas/tests/io/test_feather_sparse.py
index f430f2426050b..3cb62ce1c7b25 100644
--- a/pandas/tests/io/test_feather_sparse.py
+++ b/pandas/tests/io/test_feather_sparse.py
@@ -2,6 +2,7 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 
 pa = pytest.importorskip("pyarrow")
 
@@ -30,6 +31,6 @@ def test_feather_sparse_roundtrip(tmp_path, subtype, fill_value, data):
 
     assert isinstance(df2["s"].dtype, pd.SparseDtype)
     assert df2["s"].dtype.fill_value == fill_value
-    pd.testing.assert_series_equal(
+    tm.assert_series_equal(
         df2["s"].sparse.to_dense(), s.sparse.to_dense(), check_dtype=False
     )
diff --git a/pandas/tests/io/test_parquet_sparse.py b/pandas/tests/io/test_parquet_sparse.py
index e60881ec88a81..b2ff7c8400f80 100644
--- a/pandas/tests/io/test_parquet_sparse.py
+++ b/pandas/tests/io/test_parquet_sparse.py
@@ -2,6 +2,7 @@
 import pytest
 
 import pandas as pd
+import pandas._testing as tm
 
 pa = pytest.importorskip("pyarrow")
 
@@ -30,6 +31,6 @@ def test_parquet_sparse_roundtrip(tmp_path, subtype, fill_value, data):
 
     assert isinstance(df2["s"].dtype, pd.SparseDtype)
     assert df2["s"].dtype.fill_value == fill_value
-    pd.testing.assert_series_equal(
+    tm.assert_series_equal(
         df2["s"].sparse.to_dense(), s.sparse.to_dense(), check_dtype=False
     )