From 2d9c95ddb70f9c68e1ad4893d07bf0f68a23316e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 7 Oct 2024 10:00:48 -0700
Subject: [PATCH 01/20] Bump mamba-org/setup-micromamba from 1 to 2 (#59988)

Bumps [mamba-org/setup-micromamba](https://github.com/mamba-org/setup-micromamba) from 1 to 2.
- [Release notes](https://github.com/mamba-org/setup-micromamba/releases)
- [Commits](https://github.com/mamba-org/setup-micromamba/compare/v1...v2)

---
updated-dependencies:
- dependency-name: mamba-org/setup-micromamba
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/package-checks.yml | 2 +-
 .github/workflows/wheels.yml         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/package-checks.yml b/.github/workflows/package-checks.yml
index 6748832903e30..331af6e05b650 100644
--- a/.github/workflows/package-checks.yml
+++ b/.github/workflows/package-checks.yml
@@ -67,7 +67,7 @@ jobs:
           fetch-depth: 0
 
       - name: Set up Python
-        uses: mamba-org/setup-micromamba@v1
+        uses: mamba-org/setup-micromamba@v2
         with:
           environment-name: recipe-test
           create-args: >-
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index 2aaec8c9b56b0..de59a454c827c 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -165,7 +165,7 @@ jobs:
           CIBW_PLATFORM: ${{ matrix.buildplat[1] == 'pyodide_wasm32' && 'pyodide' || 'auto' }}
 
       - name: Set up Python
-        uses: mamba-org/setup-micromamba@v1
+        uses: mamba-org/setup-micromamba@v2
         with:
           environment-name: wheel-env
           # Use a fixed Python, since we might have an unreleased Python not

From e5dc0646bb4b945cec03cc328ac0989cfe0fa60a Mon Sep 17 00:00:00 2001
From: Tuhin Sharma <tuhinsharma121@gmail.com>
Date: Mon, 7 Oct 2024 22:44:19 +0530
Subject: [PATCH 02/20] DOC: fix RT03,SA01,ES01 for
 pandas.io.stata.StataReader.value_labels (#59991)

---
 ci/code_checks.sh  |  1 -
 pandas/io/stata.py | 10 ++++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 5487dc19338da..102abf4be187c 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -174,7 +174,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.errors.ValueLabelTypeMismatch SA01" \
         -i "pandas.infer_freq SA01" \
         -i "pandas.io.json.build_table_schema PR07,RT03,SA01" \
-        -i "pandas.io.stata.StataReader.value_labels RT03,SA01" \
         -i "pandas.io.stata.StataReader.variable_labels RT03,SA01" \
         -i "pandas.io.stata.StataWriter.write_file SA01" \
         -i "pandas.json_normalize RT03,SA01" \
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index 6b988d8fed6bf..f1d289726c9c8 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -2076,9 +2076,19 @@ def value_labels(self) -> dict[str, dict[int, str]]:
         """
         Return a nested dict associating each variable name to its value and label.
 
+        This method retrieves the value labels from a Stata file. Value labels are
+        mappings between the coded values and their corresponding descriptive labels
+        in a Stata dataset.
+
         Returns
         -------
         dict
+            A python dictionary.
+
+        See Also
+        --------
+        read_stata : Read Stata file into DataFrame.
+        DataFrame.to_stata : Export DataFrame object to Stata dta format.
 
         Examples
         --------

From b3d0b9622bcd5bdf9733100407bd8b2695bc9af6 Mon Sep 17 00:00:00 2001
From: Tuhin Sharma <tuhinsharma121@gmail.com>
Date: Mon, 7 Oct 2024 22:45:35 +0530
Subject: [PATCH 03/20] DOC: fix RT03,SA01,ES01 for pandas.plotting.lag_plot
 (#59990)

---
 ci/code_checks.sh        |  1 -
 pandas/plotting/_misc.py | 11 +++++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 102abf4be187c..6a1b613eccb8b 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -178,7 +178,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.io.stata.StataWriter.write_file SA01" \
         -i "pandas.json_normalize RT03,SA01" \
         -i "pandas.plotting.andrews_curves RT03,SA01" \
-        -i "pandas.plotting.lag_plot RT03,SA01" \
         -i "pandas.plotting.scatter_matrix PR07,SA01" \
         -i "pandas.set_eng_float_format RT03,SA01" \
         -i "pandas.tseries.offsets.BDay PR02,SA01" \
diff --git a/pandas/plotting/_misc.py b/pandas/plotting/_misc.py
index 03701f8778065..81940613dd2b0 100644
--- a/pandas/plotting/_misc.py
+++ b/pandas/plotting/_misc.py
@@ -549,6 +549,10 @@ def lag_plot(series: Series, lag: int = 1, ax: Axes | None = None, **kwds) -> Ax
     """
     Lag plot for time series.
 
+    A lag plot is a scatter plot of a time series against a lag of itself. It helps
+    in visualizing the temporal dependence between observations by plotting the values
+    at time `t` on the x-axis and the values at time `t + lag` on the y-axis.
+
     Parameters
     ----------
     series : Series
@@ -563,6 +567,13 @@ def lag_plot(series: Series, lag: int = 1, ax: Axes | None = None, **kwds) -> Ax
     Returns
     -------
     matplotlib.axes.Axes
+        The matplotlib Axes object containing the lag plot.
+
+    See Also
+    --------
+    plotting.autocorrelation_plot : Autocorrelation plot for time series.
+    matplotlib.pyplot.scatter : A scatter plot of y vs. x with varying marker size
+        and/or color in Matplotlib.
 
     Examples
     --------

From 02267e55586c33a4724dd5e9dbaecfe12e3aa8b4 Mon Sep 17 00:00:00 2001
From: Randolf Scholz <randolf.scholz@gmail.com>
Date: Mon, 7 Oct 2024 19:22:27 +0200
Subject: [PATCH 04/20] Typing: Added missing methods to `NaTType` stub
 (#59995)

added missing methods to NaTType stub
---
 pandas/_libs/tslibs/nattype.pyi | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/pandas/_libs/tslibs/nattype.pyi b/pandas/_libs/tslibs/nattype.pyi
index f49e894a0bfec..fa1577f033fff 100644
--- a/pandas/_libs/tslibs/nattype.pyi
+++ b/pandas/_libs/tslibs/nattype.pyi
@@ -9,6 +9,7 @@ from typing import (
     Literal,
     NoReturn,
     TypeAlias,
+    overload,
 )
 
 import numpy as np
@@ -159,15 +160,31 @@ class NaTType:
     # inject Period properties
     @property
     def qyear(self) -> float: ...
+    # comparisons
     def __eq__(self, other: object) -> bool: ...
     def __ne__(self, other: object) -> bool: ...
     __lt__: _NatComparison
     __le__: _NatComparison
     __gt__: _NatComparison
     __ge__: _NatComparison
+    # unary operators
+    def __pos__(self) -> Self: ...
+    def __neg__(self) -> Self: ...
+    # binary operators
     def __sub__(self, other: Self | timedelta | datetime) -> Self: ...
     def __rsub__(self, other: Self | timedelta | datetime) -> Self: ...
     def __add__(self, other: Self | timedelta | datetime) -> Self: ...
     def __radd__(self, other: Self | timedelta | datetime) -> Self: ...
+    def __mul__(self, other: float) -> Self: ...  # analogous to timedelta
+    def __rmul__(self, other: float) -> Self: ...
+    @overload  # analogous to timedelta
+    def __truediv__(self, other: Self | timedelta) -> float: ...  # Literal[NaN]
+    @overload
+    def __truediv__(self, other: float) -> Self: ...
+    @overload  # analogous to timedelta
+    def __floordiv__(self, other: Self | timedelta) -> float: ...  # Literal[NaN]
+    @overload
+    def __floordiv__(self, other: float) -> Self: ...
+    # other
     def __hash__(self) -> int: ...
     def as_unit(self, unit: str, round_ok: bool = ...) -> NaTType: ...

From 37c31afa1be8b51af545a2dc3354acaf42a9c95e Mon Sep 17 00:00:00 2001
From: Richard Shadrach <45562402+rhshadrach@users.noreply.github.com>
Date: Mon, 7 Oct 2024 18:30:40 -0400
Subject: [PATCH 05/20] REGR: groupby.value_counts with all NA values (#59999)

* REGR: groupby.value_counts with all NA values

* Better implementation
---
 pandas/core/groupby/ops.py                    |  2 +-
 .../groupby/methods/test_value_counts.py      | 22 +++++++++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index a82e77140d274..b32119a2ddbde 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -867,7 +867,7 @@ def _ob_index_and_ids(
             names=names,
             verify_integrity=False,
         )
-        if not consistent_sorting:
+        if not consistent_sorting and len(ob_index) > 0:
             # Sort by the levels where the corresponding sort argument is True
             n_levels = len(sorts)
             drop_levels = [
diff --git a/pandas/tests/groupby/methods/test_value_counts.py b/pandas/tests/groupby/methods/test_value_counts.py
index 8f3022fbe551c..8ca6593a19f20 100644
--- a/pandas/tests/groupby/methods/test_value_counts.py
+++ b/pandas/tests/groupby/methods/test_value_counts.py
@@ -1219,3 +1219,25 @@ def test_value_counts_sort_categorical(sort, vc_sort, normalize):
     expected = expected.take(taker)
 
     tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("groupby_sort", [True, False])
+def test_value_counts_all_na(sort, dropna, groupby_sort):
+    # GH#59989
+    df = DataFrame({"a": [2, 1, 1], "b": np.nan})
+    gb = df.groupby("a", sort=groupby_sort)
+    result = gb.value_counts(sort=sort, dropna=dropna)
+
+    kwargs = {"levels": [[1, 2], [np.nan]], "names": ["a", "b"]}
+    if dropna:
+        data = []
+        index = MultiIndex(codes=[[], []], **kwargs)
+    elif not groupby_sort and not sort:
+        data = [1, 2]
+        index = MultiIndex(codes=[[1, 0], [0, 0]], **kwargs)
+    else:
+        data = [2, 1]
+        index = MultiIndex(codes=[[0, 1], [0, 0]], **kwargs)
+    expected = Series(data, index=index, dtype="int64", name="count")
+
+    tm.assert_series_equal(result, expected)

From 5126dcaf88167ff869db874be40a520bb86a27ed Mon Sep 17 00:00:00 2001
From: Deepak Saldanha <saldanhadeepakuconn@gmail.com>
Date: Tue, 8 Oct 2024 08:05:04 +0530
Subject: [PATCH 06/20] Doc: Update docstring for `dummy_na` parameter (#60000)

* update docstring for dummy_na parameter

* Update pandas/core/reshape/encoding.py

Co-authored-by: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>

---------

Co-authored-by: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
---
 pandas/core/reshape/encoding.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pandas/core/reshape/encoding.py b/pandas/core/reshape/encoding.py
index c397c1c2566a5..33ff182f5baee 100644
--- a/pandas/core/reshape/encoding.py
+++ b/pandas/core/reshape/encoding.py
@@ -68,7 +68,8 @@ def get_dummies(
         If appending prefix, separator/delimiter to use. Or pass a
         list or dictionary as with `prefix`.
     dummy_na : bool, default False
-        Add a column to indicate NaNs, if False NaNs are ignored.
+        If True, a NaN indicator column will be added even if no NaN values are present.
+        If False, NA values are encoded as all zero.
     columns : list-like, default None
         Column names in the DataFrame to be encoded.
         If `columns` is None then all the columns with

From 5ea5bd95d5bb93434fb5f1686f50b176c46dbac8 Mon Sep 17 00:00:00 2001
From: Randolf Scholz <randolf.scholz@gmail.com>
Date: Tue, 8 Oct 2024 20:36:41 +0200
Subject: [PATCH 07/20] Typing: More precise NaT stub (#60002)

* more precise NaT stub

* ruff format

* updated == and != to return literal
---
 pandas/_libs/tslibs/nattype.pyi | 40 +++++++++++++++------------------
 1 file changed, 18 insertions(+), 22 deletions(-)

diff --git a/pandas/_libs/tslibs/nattype.pyi b/pandas/_libs/tslibs/nattype.pyi
index fa1577f033fff..d3b10fbe79cb9 100644
--- a/pandas/_libs/tslibs/nattype.pyi
+++ b/pandas/_libs/tslibs/nattype.pyi
@@ -25,12 +25,8 @@ NaT: NaTType
 iNaT: int
 nat_strings: set[str]
 
-_NaTComparisonTypes: TypeAlias = (
-    datetime | timedelta | Period | np.datetime64 | np.timedelta64
-)
-
-class _NatComparison:
-    def __call__(self, other: _NaTComparisonTypes) -> bool: ...
+_TimeLike: TypeAlias = datetime | timedelta | Period | np.datetime64 | np.timedelta64
+_TimeDelta: TypeAlias = timedelta | np.timedelta64
 
 class NaTType:
     _value: np.int64
@@ -161,30 +157,30 @@ class NaTType:
     @property
     def qyear(self) -> float: ...
     # comparisons
-    def __eq__(self, other: object) -> bool: ...
-    def __ne__(self, other: object) -> bool: ...
-    __lt__: _NatComparison
-    __le__: _NatComparison
-    __gt__: _NatComparison
-    __ge__: _NatComparison
+    def __eq__(self, other: object, /) -> Literal[False]: ...
+    def __ne__(self, other: object, /) -> Literal[True]: ...
+    def __lt__(self, other: Self | _TimeLike, /) -> Literal[False]: ...
+    def __le__(self, other: Self | _TimeLike, /) -> Literal[False]: ...
+    def __gt__(self, other: Self | _TimeLike, /) -> Literal[False]: ...
+    def __ge__(self, other: Self | _TimeLike, /) -> Literal[False]: ...
     # unary operators
     def __pos__(self) -> Self: ...
     def __neg__(self) -> Self: ...
     # binary operators
-    def __sub__(self, other: Self | timedelta | datetime) -> Self: ...
-    def __rsub__(self, other: Self | timedelta | datetime) -> Self: ...
-    def __add__(self, other: Self | timedelta | datetime) -> Self: ...
-    def __radd__(self, other: Self | timedelta | datetime) -> Self: ...
-    def __mul__(self, other: float) -> Self: ...  # analogous to timedelta
-    def __rmul__(self, other: float) -> Self: ...
+    def __sub__(self, other: Self | _TimeLike, /) -> Self: ...
+    def __rsub__(self, other: Self | _TimeLike, /) -> Self: ...
+    def __add__(self, other: Self | _TimeLike, /) -> Self: ...
+    def __radd__(self, other: Self | _TimeLike, /) -> Self: ...
+    def __mul__(self, other: float, /) -> Self: ...  # analogous to timedelta
+    def __rmul__(self, other: float, /) -> Self: ...
     @overload  # analogous to timedelta
-    def __truediv__(self, other: Self | timedelta) -> float: ...  # Literal[NaN]
+    def __truediv__(self, other: Self | _TimeDelta, /) -> float: ...  # Literal[NaN]
     @overload
-    def __truediv__(self, other: float) -> Self: ...
+    def __truediv__(self, other: float, /) -> Self: ...
     @overload  # analogous to timedelta
-    def __floordiv__(self, other: Self | timedelta) -> float: ...  # Literal[NaN]
+    def __floordiv__(self, other: Self | _TimeDelta, /) -> float: ...  # Literal[NaN]
     @overload
-    def __floordiv__(self, other: float) -> Self: ...
+    def __floordiv__(self, other: float, /) -> Self: ...
     # other
     def __hash__(self) -> int: ...
     def as_unit(self, unit: str, round_ok: bool = ...) -> NaTType: ...

From f94860e1ce75b57db9eda2c37154c5b22b661121 Mon Sep 17 00:00:00 2001
From: Deepak Saldanha <saldanhadeepakuconn@gmail.com>
Date: Wed, 9 Oct 2024 00:11:39 +0530
Subject: [PATCH 08/20] DOC: Refactor _create_delegator_method using functools
 (#59878)

* add tag dt.to_timestamp, series.rst

* add doc strings for dt.to_timestamp

* update datetimes.py

* refactor _create_delegator_method to use functools wrap

* changes to accessor.py

* remove from code_checks.sh

* update code_checks.sh

* update code_checks.sh

* rewrite functools, adjust unit tests

* update change log

* remove dup entry

* update code_checks.sh

* update

* revert all dt related changes

* update series.rst

* update imports

* format use of functools import
---
 ci/code_checks.sh                 | 20 --------------------
 pandas/core/accessor.py           |  7 ++++---
 pandas/core/arrays/categorical.py | 14 ++++++++++++--
 3 files changed, 16 insertions(+), 25 deletions(-)

diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 6a1b613eccb8b..6fb675069e81d 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -73,27 +73,7 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.Period.freq GL08" \
         -i "pandas.Period.ordinal GL08" \
         -i "pandas.RangeIndex.from_range PR01,SA01" \
-        -i "pandas.Series.cat.add_categories PR01,PR02" \
-        -i "pandas.Series.cat.as_ordered PR01" \
-        -i "pandas.Series.cat.as_unordered PR01" \
-        -i "pandas.Series.cat.remove_categories PR01,PR02" \
-        -i "pandas.Series.cat.remove_unused_categories PR01" \
-        -i "pandas.Series.cat.rename_categories PR01,PR02" \
-        -i "pandas.Series.cat.reorder_categories PR01,PR02" \
-        -i "pandas.Series.cat.set_categories PR01,PR02" \
-        -i "pandas.Series.dt.as_unit PR01,PR02" \
-        -i "pandas.Series.dt.ceil PR01,PR02" \
-        -i "pandas.Series.dt.day_name PR01,PR02" \
-        -i "pandas.Series.dt.floor PR01,PR02" \
         -i "pandas.Series.dt.freq GL08" \
-        -i "pandas.Series.dt.month_name PR01,PR02" \
-        -i "pandas.Series.dt.normalize PR01" \
-        -i "pandas.Series.dt.round PR01,PR02" \
-        -i "pandas.Series.dt.strftime PR01,PR02" \
-        -i "pandas.Series.dt.to_period PR01,PR02" \
-        -i "pandas.Series.dt.total_seconds PR01" \
-        -i "pandas.Series.dt.tz_convert PR01,PR02" \
-        -i "pandas.Series.dt.tz_localize PR01,PR02" \
         -i "pandas.Series.dt.unit GL08" \
         -i "pandas.Series.pad PR01,SA01" \
         -i "pandas.Timedelta.max PR02" \
diff --git a/pandas/core/accessor.py b/pandas/core/accessor.py
index d8463fda34caa..78684eacf2d66 100644
--- a/pandas/core/accessor.py
+++ b/pandas/core/accessor.py
@@ -7,6 +7,7 @@
 
 from __future__ import annotations
 
+import functools
 from typing import (
     TYPE_CHECKING,
     final,
@@ -117,12 +118,12 @@ def _setter(self, new_values):
             )
 
         def _create_delegator_method(name: str):
+            method = getattr(delegate, accessor_mapping(name))
+
+            @functools.wraps(method)
             def f(self, *args, **kwargs):
                 return self._delegate_method(name, *args, **kwargs)
 
-            f.__name__ = name
-            f.__doc__ = getattr(delegate, accessor_mapping(name)).__doc__
-
             return f
 
         for name in accessors:
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index a69e197df851d..0484ef89f61c2 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1155,6 +1155,12 @@ def rename_categories(self, new_categories) -> Self:
         """
         Rename categories.
 
+        This method is commonly used to re-label or adjust the
+        category names in categorical data without changing the
+        underlying data. It is useful in situations where you want
+        to modify the labels used for clarity, consistency,
+        or readability.
+
         Parameters
         ----------
         new_categories : list-like, dict-like or callable
@@ -1371,8 +1377,8 @@ def remove_categories(self, removals) -> Self:
         """
         Remove the specified categories.
 
-        `removals` must be included in the old categories. Values which were in
-        the removed categories will be set to NaN
+        The ``removals`` argument must be a subset of the current categories.
+        Any values that were part of the removed categories will be set to NaN.
 
         Parameters
         ----------
@@ -1431,6 +1437,10 @@ def remove_unused_categories(self) -> Self:
         """
         Remove categories which are not used.
 
+        This method is useful when working with datasets
+        that undergo dynamic changes where categories may no longer be
+        relevant, allowing to maintain a clean, efficient data structure.
+
         Returns
         -------
         Categorical

From b975191afe1401f13ab5e15d3df83b5d95dffe75 Mon Sep 17 00:00:00 2001
From: Albert Villanova del Moral
 <8515462+albertvillanova@users.noreply.github.com>
Date: Tue, 8 Oct 2024 22:00:43 +0200
Subject: [PATCH 09/20] Fix Styler docstring (#60001)

* Fix Styler docstring

* Remove blankspaces
---
 pandas/io/formats/style.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 6e5ae09485951..eb6773310da69 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -222,6 +222,7 @@ class Styler(StylerRenderer):
       * ``level<k>`` where `k` is the level in a MultiIndex
 
     * Column label cells include
+
       * ``col_heading``
       * ``col<n>`` where `n` is the numeric position of the column
       * ``level<k>`` where `k` is the level in a MultiIndex
@@ -231,7 +232,7 @@ class Styler(StylerRenderer):
     * Trimmed cells include ``col_trim`` or ``row_trim``.
 
     Any, or all, or these classes can be renamed by using the ``css_class_names``
-    argument in ``Styler.set_table_classes``, giving a value such as
+    argument in ``Styler.set_table_styles``, giving a value such as
     *{"row": "MY_ROW_CLASS", "col_trim": "", "row_trim": ""}*.
 
     Examples

From a0f9140b942d9f596889cd26ac395551dcdf3afb Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 8 Oct 2024 14:51:49 -0700
Subject: [PATCH 10/20] [pre-commit.ci] pre-commit autoupdate (#59998)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* [pre-commit.ci] pre-commit autoupdate

updates:
- [github.com/astral-sh/ruff-pre-commit: v0.5.0 → v0.6.9](https://github.com/astral-sh/ruff-pre-commit/compare/v0.5.0...v0.6.9)
- [github.com/jendrikseipp/vulture: v2.11 → v2.13](https://github.com/jendrikseipp/vulture/compare/v2.11...v2.13)
- [github.com/pre-commit/pre-commit-hooks: v4.6.0 → v5.0.0](https://github.com/pre-commit/pre-commit-hooks/compare/v4.6.0...v5.0.0)
- [github.com/asottile/pyupgrade: v3.16.0 → v3.17.0](https://github.com/asottile/pyupgrade/compare/v3.16.0...v3.17.0)
- [github.com/sphinx-contrib/sphinx-lint: v0.9.1 → v1.0.0](https://github.com/sphinx-contrib/sphinx-lint/compare/v0.9.1...v1.0.0)
- [github.com/pre-commit/mirrors-clang-format: v18.1.8 → v19.1.1](https://github.com/pre-commit/mirrors-clang-format/compare/v18.1.8...v19.1.1)

* Update .pre-commit-config.yaml

* fix style.ipynb, ignore some pylint

* pyupgrade

* Revert "pyupgrade"

This reverts commit b539c71009ff15769c501cf170ed9894a49ddcfb.

* don't bump pyupgrade

* Typo in random call

* Delete hidden cell

* Undo max/min rule from ruff

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
---
 .pre-commit-config.yaml               |  10 +-
 doc/source/user_guide/style.ipynb     | 689 ++++++++++++++------------
 pandas/core/arrays/string_.py         |   2 +-
 pandas/tests/indexes/test_old_base.py |   2 +-
 pyproject.toml                        |   9 +-
 5 files changed, 396 insertions(+), 316 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index f6717dd503c9b..7c9ebf7d94173 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -19,7 +19,7 @@ ci:
     skip: [pyright, mypy]
 repos:
 -   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.5.0
+    rev: v0.6.9
     hooks:
     -   id: ruff
         args: [--exit-non-zero-on-fix]
@@ -34,7 +34,7 @@ repos:
     -   id: ruff-format
         exclude: ^scripts|^pandas/tests/frame/test_query_eval.py
 -   repo: https://github.com/jendrikseipp/vulture
-    rev: 'v2.11'
+    rev: 'v2.13'
     hooks:
       - id: vulture
         entry: python scripts/run_vulture.py
@@ -52,7 +52,7 @@ repos:
     -   id: cython-lint
     -   id: double-quote-cython-strings
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.6.0
+    rev: v5.0.0
     hooks:
     -   id: check-case-conflict
     -   id: check-toml
@@ -90,12 +90,12 @@ repos:
         types: [text]  # overwrite types: [rst]
         types_or: [python, rst]
 -   repo: https://github.com/sphinx-contrib/sphinx-lint
-    rev: v0.9.1
+    rev: v1.0.0
     hooks:
     - id: sphinx-lint
       args: ["--enable", "all", "--disable", "line-too-long"]
 -   repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v18.1.8
+    rev: v19.1.1
     hooks:
     - id: clang-format
       files: ^pandas/_libs/src|^pandas/_libs/include
diff --git a/doc/source/user_guide/style.ipynb b/doc/source/user_guide/style.ipynb
index daecfce6ecebc..abb7181fc8d72 100644
--- a/doc/source/user_guide/style.ipynb
+++ b/doc/source/user_guide/style.ipynb
@@ -38,19 +38,6 @@
     "[concatfunc]: ../reference/api/pandas.io.formats.style.Styler.concat.rst"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "nbsphinx": "hidden"
-   },
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot\n",
-    "# We have this here to trigger matplotlib's font cache stuff.\n",
-    "# This cell is hidden from the output"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -78,17 +65,13 @@
    "source": [
     "import pandas as pd\n",
     "import numpy as np\n",
-    "import matplotlib as mpl\n",
     "\n",
-    "df = pd.DataFrame({\n",
-    "    \"strings\": [\"Adam\", \"Mike\"],\n",
-    "    \"ints\": [1, 3],\n",
-    "    \"floats\": [1.123, 1000.23]\n",
-    "})\n",
-    "df.style \\\n",
-    "  .format(precision=3, thousands=\".\", decimal=\",\") \\\n",
-    "  .format_index(str.upper, axis=1) \\\n",
-    "  .relabel_index([\"row 1\", \"row 2\"], axis=0)"
+    "df = pd.DataFrame(\n",
+    "    {\"strings\": [\"Adam\", \"Mike\"], \"ints\": [1, 3], \"floats\": [1.123, 1000.23]}\n",
+    ")\n",
+    "df.style.format(precision=3, thousands=\".\", decimal=\",\").format_index(\n",
+    "    str.upper, axis=1\n",
+    ").relabel_index([\"row 1\", \"row 2\"], axis=0)"
    ]
   },
   {
@@ -104,17 +87,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "weather_df = pd.DataFrame(np.random.rand(10,2)*5, \n",
-    "                          index=pd.date_range(start=\"2021-01-01\", periods=10),\n",
-    "                          columns=[\"Tokyo\", \"Beijing\"])\n",
+    "weather_df = pd.DataFrame(\n",
+    "    np.random.default_rng().random((10, 2)) * 5,\n",
+    "    index=pd.date_range(start=\"2021-01-01\", periods=10),\n",
+    "    columns=[\"Tokyo\", \"Beijing\"],\n",
+    ")\n",
+    "\n",
     "\n",
-    "def rain_condition(v): \n",
+    "def rain_condition(v):\n",
     "    if v < 1.75:\n",
     "        return \"Dry\"\n",
     "    elif v < 2.75:\n",
     "        return \"Rain\"\n",
     "    return \"Heavy Rain\"\n",
     "\n",
+    "\n",
     "def make_pretty(styler):\n",
     "    styler.set_caption(\"Weather Conditions\")\n",
     "    styler.format(rain_condition)\n",
@@ -122,6 +109,7 @@
     "    styler.background_gradient(axis=None, vmin=1, vmax=5, cmap=\"YlGnBu\")\n",
     "    return styler\n",
     "\n",
+    "\n",
     "weather_df"
    ]
   },
@@ -157,10 +145,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df = pd.DataFrame(np.random.randn(5, 5))\n",
-    "df.style \\\n",
-    "  .hide(subset=[0, 2, 4], axis=0) \\\n",
-    "  .hide(subset=[0, 2, 4], axis=1)"
+    "df = pd.DataFrame(np.random.default_rng().standard_normal((5, 5)))\n",
+    "df.style.hide(subset=[0, 2, 4], axis=0).hide(subset=[0, 2, 4], axis=1)"
    ]
   },
   {
@@ -177,9 +163,9 @@
    "outputs": [],
    "source": [
     "show = [0, 2, 4]\n",
-    "df.style \\\n",
-    "  .hide([row for row in df.index if row not in show], axis=0) \\\n",
-    "  .hide([col for col in df.columns if col not in show], axis=1)"
+    "df.style.hide([row for row in df.index if row not in show], axis=0).hide(\n",
+    "    [col for col in df.columns if col not in show], axis=1\n",
+    ")"
    ]
   },
   {
@@ -199,9 +185,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "summary_styler = df.agg([\"sum\", \"mean\"]).style \\\n",
-    "                   .format(precision=3) \\\n",
-    "                   .relabel_index([\"Sum\", \"Average\"])\n",
+    "summary_styler = (\n",
+    "    df.agg([\"sum\", \"mean\"]).style.format(precision=3).relabel_index([\"Sum\", \"Average\"])\n",
+    ")\n",
     "df.style.format(precision=1).concat(summary_styler)"
    ]
   },
@@ -227,9 +213,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df = pd.DataFrame([[38.0, 2.0, 18.0, 22.0, 21, np.nan],[19, 439, 6, 452, 226,232]], \n",
-    "                  index=pd.Index(['Tumour (Positive)', 'Non-Tumour (Negative)'], name='Actual Label:'), \n",
-    "                  columns=pd.MultiIndex.from_product([['Decision Tree', 'Regression', 'Random'],['Tumour', 'Non-Tumour']], names=['Model:', 'Predicted:']))\n",
+    "idx = pd.Index([\"Tumour (Positive)\", \"Non-Tumour (Negative)\"], name=\"Actual Label:\")\n",
+    "cols = pd.MultiIndex.from_product(\n",
+    "    [[\"Decision Tree\", \"Regression\", \"Random\"], [\"Tumour\", \"Non-Tumour\"]],\n",
+    "    names=[\"Model:\", \"Predicted:\"],\n",
+    ")\n",
+    "df = pd.DataFrame(\n",
+    "    [[38.0, 2.0, 18.0, 22.0, 21, np.nan], [19, 439, 6, 452, 226, 232]],\n",
+    "    index=idx,\n",
+    "    columns=cols,\n",
+    ")\n",
     "df.style"
    ]
   },
@@ -242,63 +235,68 @@
    "outputs": [],
    "source": [
     "# Hidden cell to just create the below example: code is covered throughout the guide.\n",
-    "s = df.style\\\n",
-    "      .hide([('Random', 'Tumour'), ('Random', 'Non-Tumour')], axis='columns')\\\n",
-    "      .format('{:.0f}')\\\n",
-    "      .set_table_styles([{\n",
-    "        'selector': '',\n",
-    "        'props':  'border-collapse: separate;'\n",
-    "      },{\n",
-    "        'selector': 'caption',\n",
-    "        'props': 'caption-side: bottom; font-size:1.3em;'\n",
-    "      },{\n",
-    "        'selector': '.index_name',\n",
-    "        'props': 'font-style: italic; color: darkgrey; font-weight:normal;'\n",
-    "      },{\n",
-    "        'selector': 'th:not(.index_name)',\n",
-    "        'props': 'background-color: #000066; color: white;'\n",
-    "      },{\n",
-    "        'selector': 'th.col_heading',\n",
-    "        'props': 'text-align: center;'\n",
-    "      },{\n",
-    "        'selector': 'th.col_heading.level0',\n",
-    "        'props': 'font-size: 1.5em;'\n",
-    "      },{\n",
-    "        'selector': 'th.col2',\n",
-    "        'props': 'border-left: 1px solid white;'\n",
-    "      },{\n",
-    "        'selector': '.col2',\n",
-    "        'props': 'border-left: 1px solid #000066;'\n",
-    "      },{\n",
-    "        'selector': 'td',\n",
-    "        'props': 'text-align: center; font-weight:bold;'\n",
-    "      },{\n",
-    "        'selector': '.true',\n",
-    "        'props': 'background-color: #e6ffe6;'\n",
-    "      },{\n",
-    "        'selector': '.false',\n",
-    "        'props': 'background-color: #ffe6e6;'\n",
-    "      },{\n",
-    "        'selector': '.border-red',\n",
-    "        'props': 'border: 2px dashed red;'\n",
-    "      },{\n",
-    "        'selector': '.border-green',\n",
-    "        'props': 'border: 2px dashed green;'\n",
-    "      },{\n",
-    "        'selector': 'td:hover',\n",
-    "        'props': 'background-color: #ffffb3;'\n",
-    "      }])\\\n",
-    "      .set_td_classes(pd.DataFrame([['true border-green', 'false', 'true', 'false border-red', '', ''],\n",
-    "                                    ['false', 'true', 'false', 'true', '', '']], \n",
-    "                                    index=df.index, columns=df.columns))\\\n",
-    "      .set_caption(\"Confusion matrix for multiple cancer prediction models.\")\\\n",
-    "      .set_tooltips(pd.DataFrame([['This model has a very strong true positive rate', '', '', \"This model's total number of false negatives is too high\", '', ''],\n",
-    "                                    ['', '', '', '', '', '']], \n",
-    "                                    index=df.index, columns=df.columns),\n",
-    "                   css_class='pd-tt', props=\n",
-    "    'visibility: hidden; position: absolute; z-index: 1; border: 1px solid #000066;'\n",
-    "    'background-color: white; color: #000066; font-size: 0.8em;' \n",
-    "    'transform: translate(0px, -24px); padding: 0.6em; border-radius: 0.5em;')\n"
+    "s = (\n",
+    "    df.style.hide([(\"Random\", \"Tumour\"), (\"Random\", \"Non-Tumour\")], axis=\"columns\")\n",
+    "    .format(\"{:.0f}\")\n",
+    "    .set_table_styles(\n",
+    "        [\n",
+    "            {\"selector\": \"\", \"props\": \"border-collapse: separate;\"},\n",
+    "            {\"selector\": \"caption\", \"props\": \"caption-side: bottom; font-size:1.3em;\"},\n",
+    "            {\n",
+    "                \"selector\": \".index_name\",\n",
+    "                \"props\": \"font-style: italic; color: darkgrey; font-weight:normal;\",\n",
+    "            },\n",
+    "            {\n",
+    "                \"selector\": \"th:not(.index_name)\",\n",
+    "                \"props\": \"background-color: #000066; color: white;\",\n",
+    "            },\n",
+    "            {\"selector\": \"th.col_heading\", \"props\": \"text-align: center;\"},\n",
+    "            {\"selector\": \"th.col_heading.level0\", \"props\": \"font-size: 1.5em;\"},\n",
+    "            {\"selector\": \"th.col2\", \"props\": \"border-left: 1px solid white;\"},\n",
+    "            {\"selector\": \".col2\", \"props\": \"border-left: 1px solid #000066;\"},\n",
+    "            {\"selector\": \"td\", \"props\": \"text-align: center; font-weight:bold;\"},\n",
+    "            {\"selector\": \".true\", \"props\": \"background-color: #e6ffe6;\"},\n",
+    "            {\"selector\": \".false\", \"props\": \"background-color: #ffe6e6;\"},\n",
+    "            {\"selector\": \".border-red\", \"props\": \"border: 2px dashed red;\"},\n",
+    "            {\"selector\": \".border-green\", \"props\": \"border: 2px dashed green;\"},\n",
+    "            {\"selector\": \"td:hover\", \"props\": \"background-color: #ffffb3;\"},\n",
+    "        ]\n",
+    "    )\n",
+    "    .set_td_classes(\n",
+    "        pd.DataFrame(\n",
+    "            [\n",
+    "                [\"true border-green\", \"false\", \"true\", \"false border-red\", \"\", \"\"],\n",
+    "                [\"false\", \"true\", \"false\", \"true\", \"\", \"\"],\n",
+    "            ],\n",
+    "            index=df.index,\n",
+    "            columns=df.columns,\n",
+    "        )\n",
+    "    )\n",
+    "    .set_caption(\"Confusion matrix for multiple cancer prediction models.\")\n",
+    "    .set_tooltips(\n",
+    "        pd.DataFrame(\n",
+    "            [\n",
+    "                [\n",
+    "                    \"This model has a very strong true positive rate\",\n",
+    "                    \"\",\n",
+    "                    \"\",\n",
+    "                    \"This model's total number of false negatives is too high\",\n",
+    "                    \"\",\n",
+    "                    \"\",\n",
+    "                ],\n",
+    "                [\"\", \"\", \"\", \"\", \"\", \"\"],\n",
+    "            ],\n",
+    "            index=df.index,\n",
+    "            columns=df.columns,\n",
+    "        ),\n",
+    "        css_class=\"pd-tt\",\n",
+    "        props=\"visibility: hidden; \"\n",
+    "        \"position: absolute; z-index: 1; \"\n",
+    "        \"border: 1px solid #000066;\"\n",
+    "        \"background-color: white; color: #000066; font-size: 0.8em;\"\n",
+    "        \"transform: translate(0px, -24px); padding: 0.6em; border-radius: 0.5em;\",\n",
+    "    )\n",
+    ")"
    ]
   },
   {
@@ -325,7 +323,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s = df.style.format('{:.0f}').hide([('Random', 'Tumour'), ('Random', 'Non-Tumour')], axis=\"columns\")\n",
+    "s = df.style.format(\"{:.0f}\").hide(\n",
+    "    [(\"Random\", \"Tumour\"), (\"Random\", \"Non-Tumour\")], axis=\"columns\"\n",
+    ")\n",
     "s"
    ]
   },
@@ -337,8 +337,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s.set_uuid('after_hide')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s.set_uuid(\"after_hide\")"
    ]
   },
   {
@@ -395,16 +395,16 @@
    "outputs": [],
    "source": [
     "cell_hover = {  # for row hover use <tr> instead of <td>\n",
-    "    'selector': 'td:hover',\n",
-    "    'props': [('background-color', '#ffffb3')]\n",
+    "    \"selector\": \"td:hover\",\n",
+    "    \"props\": [(\"background-color\", \"#ffffb3\")],\n",
     "}\n",
     "index_names = {\n",
-    "    'selector': '.index_name',\n",
-    "    'props': 'font-style: italic; color: darkgrey; font-weight:normal;'\n",
+    "    \"selector\": \".index_name\",\n",
+    "    \"props\": \"font-style: italic; color: darkgrey; font-weight:normal;\",\n",
     "}\n",
     "headers = {\n",
-    "    'selector': 'th:not(.index_name)',\n",
-    "    'props': 'background-color: #000066; color: white;'\n",
+    "    \"selector\": \"th:not(.index_name)\",\n",
+    "    \"props\": \"background-color: #000066; color: white;\",\n",
     "}\n",
     "s.set_table_styles([cell_hover, index_names, headers])"
    ]
@@ -417,8 +417,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s.set_uuid('after_tab_styles1')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s.set_uuid(\"after_tab_styles1\")"
    ]
   },
   {
@@ -434,11 +434,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s.set_table_styles([\n",
-    "    {'selector': 'th.col_heading', 'props': 'text-align: center;'},\n",
-    "    {'selector': 'th.col_heading.level0', 'props': 'font-size: 1.5em;'},\n",
-    "    {'selector': 'td', 'props': 'text-align: center; font-weight: bold;'},\n",
-    "], overwrite=False)"
+    "s.set_table_styles(\n",
+    "    [\n",
+    "        {\"selector\": \"th.col_heading\", \"props\": \"text-align: center;\"},\n",
+    "        {\"selector\": \"th.col_heading.level0\", \"props\": \"font-size: 1.5em;\"},\n",
+    "        {\"selector\": \"td\", \"props\": \"text-align: center; font-weight: bold;\"},\n",
+    "    ],\n",
+    "    overwrite=False,\n",
+    ")"
    ]
   },
   {
@@ -449,8 +452,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s.set_uuid('after_tab_styles2')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s.set_uuid(\"after_tab_styles2\")"
    ]
   },
   {
@@ -468,10 +471,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s.set_table_styles({\n",
-    "    ('Regression', 'Tumour'): [{'selector': 'th', 'props': 'border-left: 1px solid white'},\n",
-    "                               {'selector': 'td', 'props': 'border-left: 1px solid #000066'}]\n",
-    "}, overwrite=False, axis=0)"
+    "s.set_table_styles(\n",
+    "    {\n",
+    "        (\"Regression\", \"Tumour\"): [\n",
+    "            {\"selector\": \"th\", \"props\": \"border-left: 1px solid white\"},\n",
+    "            {\"selector\": \"td\", \"props\": \"border-left: 1px solid #000066\"},\n",
+    "        ]\n",
+    "    },\n",
+    "    overwrite=False,\n",
+    "    axis=0,\n",
+    ")"
    ]
   },
   {
@@ -482,8 +491,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s.set_uuid('xyz01')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s.set_uuid(\"xyz01\")"
    ]
   },
   {
@@ -508,7 +517,7 @@
    "outputs": [],
    "source": [
     "out = s.set_table_attributes('class=\"my-table-cls\"').to_html()\n",
-    "print(out[out.find('<table'):][:109])"
+    "print(out[out.find(\"<table\") :][:109])"
    ]
   },
   {
@@ -531,14 +540,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s.set_table_styles([  # create internal CSS classes\n",
-    "    {'selector': '.true', 'props': 'background-color: #e6ffe6;'},\n",
-    "    {'selector': '.false', 'props': 'background-color: #ffe6e6;'},\n",
-    "], overwrite=False)\n",
-    "cell_color = pd.DataFrame([['true ', 'false ', 'true ', 'false '], \n",
-    "                           ['false ', 'true ', 'false ', 'true ']], \n",
-    "                          index=df.index, \n",
-    "                          columns=df.columns[:4])\n",
+    "s.set_table_styles(\n",
+    "    [  # create internal CSS classes\n",
+    "        {\"selector\": \".true\", \"props\": \"background-color: #e6ffe6;\"},\n",
+    "        {\"selector\": \".false\", \"props\": \"background-color: #ffe6e6;\"},\n",
+    "    ],\n",
+    "    overwrite=False,\n",
+    ")\n",
+    "cell_color = pd.DataFrame(\n",
+    "    [[\"true \", \"false \", \"true \", \"false \"], [\"false \", \"true \", \"false \", \"true \"]],\n",
+    "    index=df.index,\n",
+    "    columns=df.columns[:4],\n",
+    ")\n",
     "s.set_td_classes(cell_color)"
    ]
   },
@@ -550,8 +563,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s.set_uuid('after_classes')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s.set_uuid(\"after_classes\")"
    ]
   },
   {
@@ -579,8 +592,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "np.random.seed(0)\n",
-    "df2 = pd.DataFrame(np.random.randn(10,4), columns=['A','B','C','D'])\n",
+    "df2 = pd.DataFrame(\n",
+    "    np.random.default_rng(0).standard_normal((10, 4)), columns=[\"A\", \"B\", \"C\", \"D\"]\n",
+    ")\n",
     "df2.style"
    ]
   },
@@ -597,10 +611,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def style_negative(v, props=''):\n",
+    "def style_negative(v, props=\"\"):\n",
     "    return props if v < 0 else None\n",
-    "s2 = df2.style.map(style_negative, props='color:red;')\\\n",
-    "              .map(lambda v: 'opacity: 20%;' if (v < 0.3) and (v > -0.3) else None)\n",
+    "\n",
+    "\n",
+    "s2 = df2.style.map(style_negative, props=\"color:red;\").map(\n",
+    "    lambda v: \"opacity: 20%;\" if (v < 0.3) and (v > -0.3) else None\n",
+    ")\n",
     "s2"
    ]
   },
@@ -612,8 +629,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s2.set_uuid('after_applymap')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s2.set_uuid(\"after_applymap\")"
    ]
   },
   {
@@ -629,9 +646,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def highlight_max(s, props=''):\n",
-    "    return np.where(s == np.nanmax(s.values), props, '')\n",
-    "s2.apply(highlight_max, props='color:white;background-color:darkblue', axis=0)"
+    "def highlight_max(s, props=\"\"):\n",
+    "    return np.where(s == np.nanmax(s.values), props, \"\")\n",
+    "\n",
+    "\n",
+    "s2.apply(highlight_max, props=\"color:white;background-color:darkblue\", axis=0)"
    ]
   },
   {
@@ -642,8 +661,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s2.set_uuid('after_apply')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s2.set_uuid(\"after_apply\")"
    ]
   },
   {
@@ -659,8 +678,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s2.apply(highlight_max, props='color:white;background-color:pink;', axis=1)\\\n",
-    "  .apply(highlight_max, props='color:white;background-color:purple', axis=None)"
+    "s2.apply(highlight_max, props=\"color:white;background-color:pink;\", axis=1).apply(\n",
+    "    highlight_max, props=\"color:white;background-color:purple\", axis=None\n",
+    ")"
    ]
   },
   {
@@ -671,8 +691,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s2.set_uuid('after_apply_again')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s2.set_uuid(\"after_apply_again\")"
    ]
   },
   {
@@ -713,8 +733,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s2.map_index(lambda v: \"color:pink;\" if v>4 else \"color:darkblue;\", axis=0)\n",
-    "s2.apply_index(lambda s: np.where(s.isin([\"A\", \"B\"]), \"color:pink;\", \"color:darkblue;\"), axis=1)"
+    "s2.map_index(lambda v: \"color:pink;\" if v > 4 else \"color:darkblue;\", axis=0)\n",
+    "s2.apply_index(\n",
+    "    lambda s: np.where(s.isin([\"A\", \"B\"]), \"color:pink;\", \"color:darkblue;\"), axis=1\n",
+    ")"
    ]
   },
   {
@@ -734,11 +756,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s.set_caption(\"Confusion matrix for multiple cancer prediction models.\")\\\n",
-    " .set_table_styles([{\n",
-    "     'selector': 'caption',\n",
-    "     'props': 'caption-side: bottom; font-size:1.25em;'\n",
-    " }], overwrite=False)"
+    "s.set_caption(\n",
+    "    \"Confusion matrix for multiple cancer prediction models.\"\n",
+    ").set_table_styles(\n",
+    "    [{\"selector\": \"caption\", \"props\": \"caption-side: bottom; font-size:1.25em;\"}],\n",
+    "    overwrite=False,\n",
+    ")"
    ]
   },
   {
@@ -749,8 +772,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s.set_uuid('after_caption')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s.set_uuid(\"after_caption\")"
    ]
   },
   {
@@ -768,12 +791,24 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "tt = pd.DataFrame([['This model has a very strong true positive rate', \n",
-    "                    \"This model's total number of false negatives is too high\"]], \n",
-    "                  index=['Tumour (Positive)'], columns=df.columns[[0,3]])\n",
-    "s.set_tooltips(tt, props='visibility: hidden; position: absolute; z-index: 1; border: 1px solid #000066;'\n",
-    "                         'background-color: white; color: #000066; font-size: 0.8em;' \n",
-    "                         'transform: translate(0px, -24px); padding: 0.6em; border-radius: 0.5em;')"
+    "tt = pd.DataFrame(\n",
+    "    [\n",
+    "        [\n",
+    "            \"This model has a very strong true positive rate\",\n",
+    "            \"This model's total number of false negatives is too high\",\n",
+    "        ]\n",
+    "    ],\n",
+    "    index=[\"Tumour (Positive)\"],\n",
+    "    columns=df.columns[[0, 3]],\n",
+    ")\n",
+    "s.set_tooltips(\n",
+    "    tt,\n",
+    "    props=\"visibility: hidden; position: absolute; z-index: 1; \"\n",
+    "    \"border: 1px solid #000066;\"\n",
+    "    \"background-color: white; color: #000066; font-size: 0.8em;\"\n",
+    "    \"transform: translate(0px, -24px); padding: 0.6em; \"\n",
+    "    \"border-radius: 0.5em;\",\n",
+    ")"
    ]
   },
   {
@@ -784,8 +819,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s.set_uuid('after_tooltips')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s.set_uuid(\"after_tooltips\")"
    ]
   },
   {
@@ -801,14 +836,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "s.set_table_styles([  # create internal CSS classes\n",
-    "    {'selector': '.border-red', 'props': 'border: 2px dashed red;'},\n",
-    "    {'selector': '.border-green', 'props': 'border: 2px dashed green;'},\n",
-    "], overwrite=False)\n",
-    "cell_border = pd.DataFrame([['border-green ', ' ', ' ', 'border-red '], \n",
-    "                           [' ', ' ', ' ', ' ']], \n",
-    "                          index=df.index, \n",
-    "                          columns=df.columns[:4])\n",
+    "s.set_table_styles(\n",
+    "    [  # create internal CSS classes\n",
+    "        {\"selector\": \".border-red\", \"props\": \"border: 2px dashed red;\"},\n",
+    "        {\"selector\": \".border-green\", \"props\": \"border: 2px dashed green;\"},\n",
+    "    ],\n",
+    "    overwrite=False,\n",
+    ")\n",
+    "cell_border = pd.DataFrame(\n",
+    "    [[\"border-green \", \" \", \" \", \"border-red \"], [\" \", \" \", \" \", \" \"]],\n",
+    "    index=df.index,\n",
+    "    columns=df.columns[:4],\n",
+    ")\n",
     "s.set_td_classes(cell_color + cell_border)"
    ]
   },
@@ -820,8 +859,8 @@
    },
    "outputs": [],
    "source": [
-    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting \n",
-    "s.set_uuid('after_borders')"
+    "# Hidden cell to avoid CSS clashes and latter code upcoding previous formatting\n",
+    "s.set_uuid(\"after_borders\")"
    ]
   },
   {
@@ -847,9 +886,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df3 = pd.DataFrame(np.random.randn(4,4), \n",
-    "                   pd.MultiIndex.from_product([['A', 'B'], ['r1', 'r2']]),\n",
-    "                   columns=['c1','c2','c3','c4'])\n",
+    "df3 = pd.DataFrame(\n",
+    "    np.random.default_rng().standard_normal((4, 4)),\n",
+    "    pd.MultiIndex.from_product([[\"A\", \"B\"], [\"r1\", \"r2\"]]),\n",
+    "    columns=[\"c1\", \"c2\", \"c3\", \"c4\"],\n",
+    ")\n",
     "df3"
    ]
   },
@@ -866,9 +907,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "slice_ = ['c3', 'c4']\n",
-    "df3.style.apply(highlight_max, props='color:red;', axis=0, subset=slice_)\\\n",
-    "         .set_properties(**{'background-color': '#ffffb3'}, subset=slice_)"
+    "slice_ = [\"c3\", \"c4\"]\n",
+    "df3.style.apply(\n",
+    "    highlight_max, props=\"color:red;\", axis=0, subset=slice_\n",
+    ").set_properties(**{\"background-color\": \"#ffffb3\"}, subset=slice_)"
    ]
   },
   {
@@ -885,9 +927,10 @@
    "outputs": [],
    "source": [
     "idx = pd.IndexSlice\n",
-    "slice_ = idx[idx[:,'r1'], idx['c2':'c4']]\n",
-    "df3.style.apply(highlight_max, props='color:red;', axis=0, subset=slice_)\\\n",
-    "         .set_properties(**{'background-color': '#ffffb3'}, subset=slice_)"
+    "slice_ = idx[idx[:, \"r1\"], idx[\"c2\":\"c4\"]]\n",
+    "df3.style.apply(\n",
+    "    highlight_max, props=\"color:red;\", axis=0, subset=slice_\n",
+    ").set_properties(**{\"background-color\": \"#ffffb3\"}, subset=slice_)"
    ]
   },
   {
@@ -903,9 +946,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "slice_ = idx[idx[:,'r2'], :]\n",
-    "df3.style.apply(highlight_max, props='color:red;', axis=1, subset=slice_)\\\n",
-    "         .set_properties(**{'background-color': '#ffffb3'}, subset=slice_)"
+    "slice_ = idx[idx[:, \"r2\"], :]\n",
+    "df3.style.apply(\n",
+    "    highlight_max, props=\"color:red;\", axis=1, subset=slice_\n",
+    ").set_properties(**{\"background-color\": \"#ffffb3\"}, subset=slice_)"
    ]
   },
   {
@@ -923,9 +967,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "slice_ = idx[idx[(df3['c1'] + df3['c3']) < -2.0], ['c2', 'c4']]\n",
-    "df3.style.apply(highlight_max, props='color:red;', axis=1, subset=slice_)\\\n",
-    "         .set_properties(**{'background-color': '#ffffb3'}, subset=slice_)"
+    "slice_ = idx[idx[(df3[\"c1\"] + df3[\"c3\"]) < -2.0], [\"c2\", \"c4\"]]\n",
+    "df3.style.apply(\n",
+    "    highlight_max, props=\"color:red;\", axis=1, subset=slice_\n",
+    ").set_properties(**{\"background-color\": \"#ffffb3\"}, subset=slice_)"
    ]
   },
   {
@@ -981,7 +1026,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4 = pd.DataFrame([[1,2],[3,4]])\n",
+    "df4 = pd.DataFrame([[1, 2], [3, 4]])\n",
     "s4 = df4.style"
    ]
   },
@@ -1003,6 +1048,7 @@
    "outputs": [],
    "source": [
     "from pandas.io.formats.style import Styler\n",
+    "\n",
     "s4 = Styler(df4, uuid_len=0, cell_ids=False)"
    ]
   },
@@ -1053,7 +1099,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4.style.set_table_styles([{'selector': 'td.col1', 'props': props}])"
+    "df4.style.set_table_styles([{\"selector\": \"td.col1\", \"props\": props}])"
    ]
   },
   {
@@ -1082,9 +1128,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df2.style.apply(highlight_max, props='color:white;background-color:darkblue;', axis=0)\\\n",
-    "         .apply(highlight_max, props='color:white;background-color:pink;', axis=1)\\\n",
-    "         .apply(highlight_max, props='color:white;background-color:purple', axis=None)"
+    "df2.style.apply(\n",
+    "    highlight_max, props=\"color:white;background-color:darkblue;\", axis=0\n",
+    ").apply(highlight_max, props=\"color:white;background-color:pink;\", axis=1).apply(\n",
+    "    highlight_max, props=\"color:white;background-color:purple\", axis=None\n",
+    ")"
    ]
   },
   {
@@ -1105,14 +1153,18 @@
    "outputs": [],
    "source": [
     "build = lambda x: pd.DataFrame(x, index=df2.index, columns=df2.columns)\n",
-    "cls1 = build(df2.apply(highlight_max, props='cls-1 ', axis=0))\n",
-    "cls2 = build(df2.apply(highlight_max, props='cls-2 ', axis=1, result_type='expand').values)\n",
-    "cls3 = build(highlight_max(df2, props='cls-3 '))\n",
-    "df2.style.set_table_styles([\n",
-    "    {'selector': '.cls-1', 'props': 'color:white;background-color:darkblue;'},\n",
-    "    {'selector': '.cls-2', 'props': 'color:white;background-color:pink;'},\n",
-    "    {'selector': '.cls-3', 'props': 'color:white;background-color:purple;'}\n",
-    "]).set_td_classes(cls1 + cls2 + cls3)"
+    "cls1 = build(df2.apply(highlight_max, props=\"cls-1 \", axis=0))\n",
+    "cls2 = build(\n",
+    "    df2.apply(highlight_max, props=\"cls-2 \", axis=1, result_type=\"expand\").values\n",
+    ")\n",
+    "cls3 = build(highlight_max(df2, props=\"cls-3 \"))\n",
+    "df2.style.set_table_styles(\n",
+    "    [\n",
+    "        {\"selector\": \".cls-1\", \"props\": \"color:white;background-color:darkblue;\"},\n",
+    "        {\"selector\": \".cls-2\", \"props\": \"color:white;background-color:pink;\"},\n",
+    "        {\"selector\": \".cls-3\", \"props\": \"color:white;background-color:purple;\"},\n",
+    "    ]\n",
+    ").set_td_classes(cls1 + cls2 + cls3)"
    ]
   },
   {
@@ -1152,10 +1204,14 @@
     "    \"blank\": \"\",\n",
     "}\n",
     "html = Styler(df4, uuid_len=0, cell_ids=False)\n",
-    "html.set_table_styles([{'selector': 'td', 'props': props},\n",
-    "                       {'selector': '.c1', 'props': 'color:green;'},\n",
-    "                       {'selector': '.l0', 'props': 'color:blue;'}],\n",
-    "                      css_class_names=my_css)\n",
+    "html.set_table_styles(\n",
+    "    [\n",
+    "        {\"selector\": \"td\", \"props\": props},\n",
+    "        {\"selector\": \".c1\", \"props\": \"color:green;\"},\n",
+    "        {\"selector\": \".l0\", \"props\": \"color:blue;\"},\n",
+    "    ],\n",
+    "    css_class_names=my_css,\n",
+    ")\n",
     "print(html.to_html())"
    ]
   },
@@ -1213,9 +1269,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df2.iloc[0,2] = np.nan\n",
-    "df2.iloc[4,3] = np.nan\n",
-    "df2.loc[:4].style.highlight_null(color='yellow')"
+    "df2.iloc[0, 2] = np.nan\n",
+    "df2.iloc[4, 3] = np.nan\n",
+    "df2.loc[:4].style.highlight_null(color=\"yellow\")"
    ]
   },
   {
@@ -1231,7 +1287,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df2.loc[:4].style.highlight_max(axis=1, props='color:white; font-weight:bold; background-color:darkblue;')"
+    "df2.loc[:4].style.highlight_max(\n",
+    "    axis=1, props=(\"color:white; \" \"font-weight:bold; \" \"background-color:darkblue;\")\n",
+    ")"
    ]
   },
   {
@@ -1249,7 +1307,9 @@
    "outputs": [],
    "source": [
     "left = pd.Series([1.0, 0.0, 1.0], index=[\"A\", \"B\", \"D\"])\n",
-    "df2.loc[:4].style.highlight_between(left=left, right=1.5, axis=1, props='color:white; background-color:purple;')"
+    "df2.loc[:4].style.highlight_between(\n",
+    "    left=left, right=1.5, axis=1, props=\"color:white; background-color:purple;\"\n",
+    ")"
    ]
   },
   {
@@ -1266,7 +1326,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df2.loc[:4].style.highlight_quantile(q_left=0.85, axis=None, color='yellow')"
+    "df2.loc[:4].style.highlight_quantile(q_left=0.85, axis=None, color=\"yellow\")"
    ]
   },
   {
@@ -1290,6 +1350,7 @@
    "outputs": [],
    "source": [
     "import seaborn as sns\n",
+    "\n",
     "cm = sns.light_palette(\"green\", as_cmap=True)\n",
     "\n",
     "df2.style.background_gradient(cmap=cm)"
@@ -1329,9 +1390,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df2.loc[:4].style.set_properties(**{'background-color': 'black',\n",
-    "                           'color': 'lawngreen',\n",
-    "                           'border-color': 'white'})"
+    "df2.loc[:4].style.set_properties(\n",
+    "    **{\"background-color\": \"black\", \"color\": \"lawngreen\", \"border-color\": \"white\"}\n",
+    ")"
    ]
   },
   {
@@ -1354,7 +1415,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df2.style.bar(subset=['A', 'B'], color='#d65f5f')"
+    "df2.style.bar(subset=[\"A\", \"B\"], color=\"#d65f5f\")"
    ]
   },
   {
@@ -1372,10 +1433,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df2.style.format('{:.3f}', na_rep=\"\")\\\n",
-    "         .bar(align=0, vmin=-2.5, vmax=2.5, cmap=\"bwr\", height=50,\n",
-    "              width=60, props=\"width: 120px; border-right: 1px solid black;\")\\\n",
-    "         .text_gradient(cmap=\"bwr\", vmin=-2.5, vmax=2.5)"
+    "df2.style.format(\"{:.3f}\", na_rep=\"\").bar(\n",
+    "    align=0,\n",
+    "    vmin=-2.5,\n",
+    "    vmax=2.5,\n",
+    "    cmap=\"bwr\",\n",
+    "    height=50,\n",
+    "    width=60,\n",
+    "    props=\"width: 120px; border-right: 1px solid black;\",\n",
+    ").text_gradient(cmap=\"bwr\", vmin=-2.5, vmax=2.5)"
    ]
   },
   {
@@ -1398,10 +1464,10 @@
     "from IPython.display import HTML\n",
     "\n",
     "# Test series\n",
-    "test1 = pd.Series([-100,-60,-30,-20], name='All Negative')\n",
-    "test2 = pd.Series([-10,-5,0,90], name='Both Pos and Neg')\n",
-    "test3 = pd.Series([10,20,50,100], name='All Positive')\n",
-    "test4 = pd.Series([100, 103, 101, 102], name='Large Positive')\n",
+    "test1 = pd.Series([-100, -60, -30, -20], name=\"All Negative\")\n",
+    "test2 = pd.Series([-10, -5, 0, 90], name=\"Both Pos and Neg\")\n",
+    "test3 = pd.Series([10, 20, 50, 100], name=\"All Positive\")\n",
+    "test4 = pd.Series([100, 103, 101, 102], name=\"Large Positive\")\n",
     "\n",
     "\n",
     "head = \"\"\"\n",
@@ -1417,19 +1483,22 @@
     "\n",
     "\"\"\"\n",
     "\n",
-    "aligns = ['left', 'right', 'zero', 'mid', 'mean', 99]\n",
+    "aligns = [\"left\", \"right\", \"zero\", \"mid\", \"mean\", 99]\n",
     "for align in aligns:\n",
     "    row = \"<tr><th>{}</th>\".format(align)\n",
-    "    for series in [test1,test2,test3, test4]:\n",
+    "    for series in [test1, test2, test3, test4]:\n",
     "        s = series.copy()\n",
-    "        s.name=''\n",
-    "        row += \"<td>{}</td>\".format(s.to_frame().style.hide(axis='index').bar(align=align, \n",
-    "                                                           color=['#d65f5f', '#5fba7d'], \n",
-    "                                                           width=100).to_html()) #testn['width']\n",
-    "    row += '</tr>'\n",
+    "        s.name = \"\"\n",
+    "        row += \"<td>{}</td>\".format(\n",
+    "            s.to_frame()\n",
+    "            .style.hide(axis=\"index\")\n",
+    "            .bar(align=align, color=[\"#d65f5f\", \"#5fba7d\"], width=100)\n",
+    "            .to_html()\n",
+    "        )  # testn['width']\n",
+    "    row += \"</tr>\"\n",
     "    head += row\n",
-    "    \n",
-    "head+= \"\"\"\n",
+    "\n",
+    "head += \"\"\"\n",
     "</tbody>\n",
     "</table>\"\"\""
    ]
@@ -1463,11 +1532,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "style1 = df2.style\\\n",
-    "            .map(style_negative, props='color:red;')\\\n",
-    "            .map(lambda v: 'opacity: 20%;' if (v < 0.3) and (v > -0.3) else None)\\\n",
-    "            .set_table_styles([{\"selector\": \"th\", \"props\": \"color: blue;\"}])\\\n",
-    "            .hide(axis=\"index\")\n",
+    "style1 = (\n",
+    "    df2.style.map(style_negative, props=\"color:red;\")\n",
+    "    .map(lambda v: \"opacity: 20%;\" if (v < 0.3) and (v > -0.3) else None)\n",
+    "    .set_table_styles([{\"selector\": \"th\", \"props\": \"color: blue;\"}])\n",
+    "    .hide(axis=\"index\")\n",
+    ")\n",
     "style1"
    ]
   },
@@ -1526,11 +1596,14 @@
    "outputs": [],
    "source": [
     "from ipywidgets import widgets\n",
+    "\n",
+    "\n",
     "@widgets.interact\n",
-    "def f(h_neg=(0, 359, 1), h_pos=(0, 359), s=(0., 99.9), l=(0., 99.9)):\n",
+    "def f(h_neg=(0, 359, 1), h_pos=(0, 359), s=(0.0, 99.9), l_post=(0.0, 99.9)):\n",
     "    return df2.style.background_gradient(\n",
-    "        cmap=sns.palettes.diverging_palette(h_neg=h_neg, h_pos=h_pos, s=s, l=l,\n",
-    "                                            as_cmap=True)\n",
+    "        cmap=sns.palettes.diverging_palette(\n",
+    "            h_neg=h_neg, h_pos=h_pos, s=s, l=l_post, as_cmap=True\n",
+    "        )\n",
     "    )"
    ]
   },
@@ -1548,16 +1621,15 @@
    "outputs": [],
    "source": [
     "def magnify():\n",
-    "    return [dict(selector=\"th\",\n",
-    "                 props=[(\"font-size\", \"4pt\")]),\n",
-    "            dict(selector=\"td\",\n",
-    "                 props=[('padding', \"0em 0em\")]),\n",
-    "            dict(selector=\"th:hover\",\n",
-    "                 props=[(\"font-size\", \"12pt\")]),\n",
-    "            dict(selector=\"tr:hover td:hover\",\n",
-    "                 props=[('max-width', '200px'),\n",
-    "                        ('font-size', '12pt')])\n",
-    "]"
+    "    return [\n",
+    "        {\"selector\": \"th\", \"props\": [(\"font-size\", \"4pt\")]},\n",
+    "        {\"selector\": \"td\", \"props\": [(\"padding\", \"0em 0em\")]},\n",
+    "        {\"selector\": \"th:hover\", \"props\": [(\"font-size\", \"12pt\")]},\n",
+    "        {\n",
+    "            \"selector\": \"tr:hover td:hover\",\n",
+    "            \"props\": [(\"max-width\", \"200px\"), (\"font-size\", \"12pt\")],\n",
+    "        },\n",
+    "    ]"
    ]
   },
   {
@@ -1566,15 +1638,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "np.random.seed(25)\n",
-    "cmap = cmap=sns.diverging_palette(5, 250, as_cmap=True)\n",
-    "bigdf = pd.DataFrame(np.random.randn(20, 25)).cumsum()\n",
+    "cmap = sns.diverging_palette(5, 250, as_cmap=True)\n",
+    "bigdf = pd.DataFrame(np.random.default_rng(25).standard_normal((20, 25))).cumsum()\n",
     "\n",
-    "bigdf.style.background_gradient(cmap, axis=1)\\\n",
-    "    .set_properties(**{'max-width': '80px', 'font-size': '1pt'})\\\n",
-    "    .set_caption(\"Hover to magnify\")\\\n",
-    "    .format(precision=2)\\\n",
-    "    .set_table_styles(magnify())"
+    "bigdf.style.background_gradient(cmap, axis=1).set_properties(\n",
+    "    **{\"max-width\": \"80px\", \"font-size\": \"1pt\"}\n",
+    ").set_caption(\"Hover to magnify\").format(precision=2).set_table_styles(magnify())"
    ]
   },
   {
@@ -1594,7 +1663,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "bigdf = pd.DataFrame(np.random.randn(16, 100))\n",
+    "bigdf = pd.DataFrame(np.random.default_rng().standard_normal((16, 100)))\n",
     "bigdf.style.set_sticky(axis=\"index\")"
    ]
   },
@@ -1611,8 +1680,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "bigdf.index = pd.MultiIndex.from_product([[\"A\",\"B\"],[0,1],[0,1,2,3]])\n",
-    "bigdf.style.set_sticky(axis=\"index\", pixel_size=18, levels=[1,2])"
+    "bigdf.index = pd.MultiIndex.from_product([[\"A\", \"B\"], [0, 1], [0, 1, 2, 3]])\n",
+    "bigdf.style.set_sticky(axis=\"index\", pixel_size=18, levels=[1, 2])"
    ]
   },
   {
@@ -1632,7 +1701,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4 = pd.DataFrame([['<div></div>', '\"&other\"', '<span></span>']])\n",
+    "df4 = pd.DataFrame([[\"<div></div>\", '\"&other\"', \"<span></span>\"]])\n",
     "df4.style"
    ]
   },
@@ -1651,7 +1720,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4.style.format('<a href=\"https://pandas.pydata.org\" target=\"_blank\">{}</a>', escape=\"html\")"
+    "df4.style.format(\n",
+    "    '<a href=\"https://pandas.pydata.org\" target=\"_blank\">{}</a>', escape=\"html\"\n",
+    ")"
    ]
   },
   {
@@ -1693,10 +1764,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df2.style.\\\n",
-    "    map(style_negative, props='color:red;').\\\n",
-    "    highlight_max(axis=0).\\\n",
-    "    to_excel('styled.xlsx', engine='openpyxl')"
+    "df2.style.map(style_negative, props=\"color:red;\").highlight_max(axis=0).to_excel(\n",
+    "    \"styled.xlsx\", engine=\"openpyxl\"\n",
+    ")"
    ]
   },
   {
@@ -1765,7 +1835,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(pd.DataFrame([[1,2],[3,4]], index=['i1', 'i2'], columns=['c1', 'c2']).style.to_html())"
+    "print(\n",
+    "    pd.DataFrame(\n",
+    "        [[1, 2], [3, 4]], index=[\"i1\", \"i2\"], columns=[\"c1\", \"c2\"]\n",
+    "    ).style.to_html()\n",
+    ")"
    ]
   },
   {
@@ -1783,9 +1857,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4 = pd.DataFrame([['text']])\n",
-    "df4.style.map(lambda x: 'color:green;')\\\n",
-    "         .map(lambda x: 'color:red;')"
+    "df4 = pd.DataFrame([[\"text\"]])\n",
+    "df4.style.map(lambda x: \"color:green;\").map(lambda x: \"color:red;\")"
    ]
   },
   {
@@ -1794,8 +1867,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4.style.map(lambda x: 'color:red;')\\\n",
-    "         .map(lambda x: 'color:green;')"
+    "df4.style.map(lambda x: \"color:red;\").map(lambda x: \"color:green;\")"
    ]
   },
   {
@@ -1820,9 +1892,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4.style.set_uuid('a_')\\\n",
-    "         .set_table_styles([{'selector': 'td', 'props': 'color:red;'}])\\\n",
-    "         .map(lambda x: 'color:green;')"
+    "df4.style.set_uuid(\"a_\").set_table_styles(\n",
+    "    [{\"selector\": \"td\", \"props\": \"color:red;\"}]\n",
+    ").map(lambda x: \"color:green;\")"
    ]
   },
   {
@@ -1838,11 +1910,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4.style.set_uuid('b_')\\\n",
-    "         .set_table_styles([{'selector': 'td', 'props': 'color:red;'},\n",
-    "                            {'selector': '.cls-1', 'props': 'color:blue;'}])\\\n",
-    "         .map(lambda x: 'color:green;')\\\n",
-    "         .set_td_classes(pd.DataFrame([['cls-1']]))"
+    "df4.style.set_uuid(\"b_\").set_table_styles(\n",
+    "    [\n",
+    "        {\"selector\": \"td\", \"props\": \"color:red;\"},\n",
+    "        {\"selector\": \".cls-1\", \"props\": \"color:blue;\"},\n",
+    "    ]\n",
+    ").map(lambda x: \"color:green;\").set_td_classes(pd.DataFrame([[\"cls-1\"]]))"
    ]
   },
   {
@@ -1858,12 +1931,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4.style.set_uuid('c_')\\\n",
-    "         .set_table_styles([{'selector': 'td', 'props': 'color:red;'},\n",
-    "                            {'selector': '.cls-1', 'props': 'color:blue;'},\n",
-    "                            {'selector': 'td.data', 'props': 'color:yellow;'}])\\\n",
-    "         .map(lambda x: 'color:green;')\\\n",
-    "         .set_td_classes(pd.DataFrame([['cls-1']]))"
+    "df4.style.set_uuid(\"c_\").set_table_styles(\n",
+    "    [\n",
+    "        {\"selector\": \"td\", \"props\": \"color:red;\"},\n",
+    "        {\"selector\": \".cls-1\", \"props\": \"color:blue;\"},\n",
+    "        {\"selector\": \"td.data\", \"props\": \"color:yellow;\"},\n",
+    "    ]\n",
+    ").map(lambda x: \"color:green;\").set_td_classes(pd.DataFrame([[\"cls-1\"]]))"
    ]
   },
   {
@@ -1881,12 +1955,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df4.style.set_uuid('d_')\\\n",
-    "         .set_table_styles([{'selector': 'td', 'props': 'color:red;'},\n",
-    "                            {'selector': '.cls-1', 'props': 'color:blue;'},\n",
-    "                            {'selector': 'td.data', 'props': 'color:yellow;'}])\\\n",
-    "         .map(lambda x: 'color:green !important;')\\\n",
-    "         .set_td_classes(pd.DataFrame([['cls-1']]))"
+    "df4.style.set_uuid(\"d_\").set_table_styles(\n",
+    "    [\n",
+    "        {\"selector\": \"td\", \"props\": \"color:red;\"},\n",
+    "        {\"selector\": \".cls-1\", \"props\": \"color:blue;\"},\n",
+    "        {\"selector\": \"td.data\", \"props\": \"color:yellow;\"},\n",
+    "    ]\n",
+    ").map(lambda x: \"color:green !important;\").set_td_classes(pd.DataFrame([[\"cls-1\"]]))"
    ]
   },
   {
@@ -1940,8 +2015,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "with open(\"templates/myhtml.tpl\") as f:\n",
-    "    print(f.read())"
+    "with open(\"templates/myhtml.tpl\") as f_html:\n",
+    "    print(f_html.read())"
    ]
   },
   {
@@ -1960,10 +2035,12 @@
    "source": [
     "class MyStyler(Styler):\n",
     "    env = Environment(\n",
-    "        loader=ChoiceLoader([\n",
-    "            FileSystemLoader(\"templates\"),  # contains ours\n",
-    "            Styler.loader,  # the default\n",
-    "        ])\n",
+    "        loader=ChoiceLoader(\n",
+    "            [\n",
+    "                FileSystemLoader(\"templates\"),  # contains ours\n",
+    "                Styler.loader,  # the default\n",
+    "            ]\n",
+    "        )\n",
     "    )\n",
     "    template_html_table = env.get_template(\"myhtml.tpl\")"
    ]
@@ -2045,8 +2122,8 @@
    },
    "outputs": [],
    "source": [
-    "with open(\"templates/html_style_structure.html\") as f:\n",
-    "    style_structure = f.read()"
+    "with open(\"templates/html_style_structure.html\") as f_sty:\n",
+    "    style_structure = f_sty.read()"
    ]
   },
   {
@@ -2073,8 +2150,8 @@
    },
    "outputs": [],
    "source": [
-    "with open(\"templates/html_table_structure.html\") as f:\n",
-    "    table_structure = f.read()"
+    "with open(\"templates/html_table_structure.html\") as f_table_struct:\n",
+    "    table_structure = f_table_struct.read()"
    ]
   },
   {
@@ -2106,7 +2183,7 @@
     "# from IPython.display import HTML\n",
     "# with open(\"themes/nature_with_gtoc/static/nature.css_t\") as f:\n",
     "#     css = f.read()\n",
-    "    \n",
+    "\n",
     "# HTML('<style>{}</style>'.format(css))"
    ]
   }
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index b3aa782341c77..e4daf9ed450fb 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -190,7 +190,7 @@ def __eq__(self, other: object) -> bool:
         # cannot be checked with normal `==`
         if isinstance(other, str):
             # TODO should dtype == "string" work for the NaN variant?
-            if other == "string" or other == self.name:  # noqa: PLR1714
+            if other == "string" or other == self.name:
                 return True
             try:
                 other = self.construct_from_string(other)
diff --git a/pandas/tests/indexes/test_old_base.py b/pandas/tests/indexes/test_old_base.py
index cd3d599abd30e..0199e21bfc980 100644
--- a/pandas/tests/indexes/test_old_base.py
+++ b/pandas/tests/indexes/test_old_base.py
@@ -455,7 +455,7 @@ def test_insert_out_of_bounds(self, index, using_infer_string):
             msg = "slice indices must be integers or None or have an __index__ method"
 
         if using_infer_string and (
-            index.dtype == "string" or index.dtype == "category"  # noqa: PLR1714
+            index.dtype == "string" or index.dtype == "category"
         ):
             msg = "loc must be an integer between"
 
diff --git a/pyproject.toml b/pyproject.toml
index d0fcdc4b21b33..1386546996bf2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -324,7 +324,8 @@ ignore = [
   "PT019",
   # The following rules may cause conflicts when used with the formatter:
   "ISC001",
-
+  # if-stmt-min-max
+  "PLR1730",
 
   ### TODO: Enable gradually
   # Useless statement
@@ -341,8 +342,10 @@ ignore = [
   "RUF012",
   # type-comparison
   "E721",
-
-  # Additional pylint rules
+  # repeated-equality-comparison
+  "PLR1714",
+  # self-or-cls-assignment
+  "PLW0642",
   # literal-membership
   "PLR6201", # 847 errors
   # Method could be a function, class method, or static method

From 3f423cd12efa69bebf43e0fda397952339a2ad79 Mon Sep 17 00:00:00 2001
From: sunlight <138234530+sunlight798@users.noreply.github.com>
Date: Thu, 10 Oct 2024 01:14:11 +0800
Subject: [PATCH 11/20] DOC: fix RT03,SA01,ES01 for
 pandas.io.stata.StataReader.variable_labels (#60008)

---
 ci/code_checks.sh  |  1 -
 pandas/io/stata.py | 10 ++++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 6fb675069e81d..79a8cbdf3ea05 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -154,7 +154,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.errors.ValueLabelTypeMismatch SA01" \
         -i "pandas.infer_freq SA01" \
         -i "pandas.io.json.build_table_schema PR07,RT03,SA01" \
-        -i "pandas.io.stata.StataReader.variable_labels RT03,SA01" \
         -i "pandas.io.stata.StataWriter.write_file SA01" \
         -i "pandas.json_normalize RT03,SA01" \
         -i "pandas.plotting.andrews_curves RT03,SA01" \
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index f1d289726c9c8..04bd1e32603f4 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -2045,9 +2045,19 @@ def variable_labels(self) -> dict[str, str]:
         """
         Return a dict associating each variable name with corresponding label.
 
+        This method retrieves variable labels from a Stata file. Variable labels are
+        mappings between variable names and their corresponding descriptive labels
+        in a Stata dataset.
+
         Returns
         -------
         dict
+            A python dictionary.
+
+        See Also
+        --------
+        read_stata : Read Stata file into DataFrame.
+        DataFrame.to_stata : Export DataFrame object to Stata dta format.
 
         Examples
         --------

From 6c1f95d5f7ca83e1f55b9957229e2c1b88c5a934 Mon Sep 17 00:00:00 2001
From: LOCHAN PAUDEL <104910006+nahcol10@users.noreply.github.com>
Date: Wed, 9 Oct 2024 23:48:53 +0530
Subject: [PATCH 12/20] Programming Language :: Python :: 3.13 added to
 pyproject.toml (#59985)

* Programming Language :: Python :: 3.13 added to pyproject.toml

* pyproject.toml updated successfully
---
 pyproject.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyproject.toml b/pyproject.toml
index 1386546996bf2..d6a963e94f5b8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -45,6 +45,7 @@ classifiers = [
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
     'Topic :: Scientific/Engineering'
 ]
 

From 8303af3fd0e8d947c7d0722497f36a8e479be14d Mon Sep 17 00:00:00 2001
From: Tuhin Sharma <tuhinsharma121@gmail.com>
Date: Thu, 10 Oct 2024 00:34:58 +0530
Subject: [PATCH 13/20] DOC: fix SA01,ES01 for
 pandas.errors.CategoricalConversionWarning (#60011)

---
 ci/code_checks.sh         | 1 -
 pandas/errors/__init__.py | 9 +++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 79a8cbdf3ea05..1974c98a1d1ff 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -134,7 +134,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.core.resample.Resampler.var SA01" \
         -i "pandas.errors.AttributeConflictWarning SA01" \
         -i "pandas.errors.CSSWarning SA01" \
-        -i "pandas.errors.CategoricalConversionWarning SA01" \
         -i "pandas.errors.ChainedAssignmentError SA01" \
         -i "pandas.errors.DataError SA01" \
         -i "pandas.errors.DuplicateLabelError SA01" \
diff --git a/pandas/errors/__init__.py b/pandas/errors/__init__.py
index cf2a9d3f4a238..efc032b0b559e 100644
--- a/pandas/errors/__init__.py
+++ b/pandas/errors/__init__.py
@@ -731,6 +731,15 @@ class CategoricalConversionWarning(Warning):
     """
     Warning is raised when reading a partial labeled Stata file using a iterator.
 
+    This warning helps ensure data integrity and alerts users to potential issues
+    during the incremental reading of Stata files with labeled data, allowing for
+    additional checks and adjustments as necessary.
+
+    See Also
+    --------
+    read_stata : Read a Stata file into a DataFrame.
+    Categorical : Represents a categorical variable in pandas.
+
     Examples
     --------
     >>> from pandas.io.stata import StataReader

From 88554d0ca77c7b80605a34f9ece838b834db8720 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Thu, 10 Oct 2024 15:04:25 +0200
Subject: [PATCH 14/20] String dtype: propagate NaNs as False in predicate
 methods (eg .str.startswith) (#59616)

---
 pandas/core/arrays/_arrow_string_mixins.py |  44 +++--
 pandas/core/arrays/arrow/array.py          |   4 +-
 pandas/core/arrays/categorical.py          |  20 ++-
 pandas/core/arrays/string_.py              |  31 ++--
 pandas/core/arrays/string_arrow.py         |  40 +++--
 pandas/core/strings/accessor.py            |  40 +++--
 pandas/core/strings/base.py                |  10 +-
 pandas/core/strings/object_array.py        |  33 ++--
 pandas/tests/strings/test_api.py           |   9 +-
 pandas/tests/strings/test_find_replace.py  | 191 ++++++++++++++-------
 pandas/tests/strings/test_string_array.py  |   2 +-
 pandas/tests/strings/test_strings.py       |  29 +++-
 12 files changed, 307 insertions(+), 146 deletions(-)

diff --git a/pandas/core/arrays/_arrow_string_mixins.py b/pandas/core/arrays/_arrow_string_mixins.py
index aa5b28c71b12a..2d1b1eca55e98 100644
--- a/pandas/core/arrays/_arrow_string_mixins.py
+++ b/pandas/core/arrays/_arrow_string_mixins.py
@@ -10,6 +10,7 @@
 
 import numpy as np
 
+from pandas._libs import lib
 from pandas.compat import (
     pa_version_under10p1,
     pa_version_under11p0,
@@ -17,8 +18,6 @@
     pa_version_under17p0,
 )
 
-from pandas.core.dtypes.missing import isna
-
 if not pa_version_under10p1:
     import pyarrow as pa
     import pyarrow.compute as pc
@@ -38,7 +37,7 @@ class ArrowStringArrayMixin:
     def __init__(self, *args, **kwargs) -> None:
         raise NotImplementedError
 
-    def _convert_bool_result(self, result):
+    def _convert_bool_result(self, result, na=lib.no_default, method_name=None):
         # Convert a bool-dtype result to the appropriate result type
         raise NotImplementedError
 
@@ -212,7 +211,9 @@ def _str_removesuffix(self, suffix: str):
         result = pc.if_else(ends_with, removed, self._pa_array)
         return type(self)(result)
 
-    def _str_startswith(self, pat: str | tuple[str, ...], na: Scalar | None = None):
+    def _str_startswith(
+        self, pat: str | tuple[str, ...], na: Scalar | lib.NoDefault = lib.no_default
+    ):
         if isinstance(pat, str):
             result = pc.starts_with(self._pa_array, pattern=pat)
         else:
@@ -225,11 +226,11 @@ def _str_startswith(self, pat: str | tuple[str, ...], na: Scalar | None = None):
 
                 for p in pat[1:]:
                     result = pc.or_(result, pc.starts_with(self._pa_array, pattern=p))
-        if not isna(na):  # pyright: ignore [reportGeneralTypeIssues]
-            result = result.fill_null(na)
-        return self._convert_bool_result(result)
+        return self._convert_bool_result(result, na=na, method_name="startswith")
 
-    def _str_endswith(self, pat: str | tuple[str, ...], na: Scalar | None = None):
+    def _str_endswith(
+        self, pat: str | tuple[str, ...], na: Scalar | lib.NoDefault = lib.no_default
+    ):
         if isinstance(pat, str):
             result = pc.ends_with(self._pa_array, pattern=pat)
         else:
@@ -242,9 +243,7 @@ def _str_endswith(self, pat: str | tuple[str, ...], na: Scalar | None = None):
 
                 for p in pat[1:]:
                     result = pc.or_(result, pc.ends_with(self._pa_array, pattern=p))
-        if not isna(na):  # pyright: ignore [reportGeneralTypeIssues]
-            result = result.fill_null(na)
-        return self._convert_bool_result(result)
+        return self._convert_bool_result(result, na=na, method_name="endswith")
 
     def _str_isalnum(self):
         result = pc.utf8_is_alnum(self._pa_array)
@@ -283,7 +282,12 @@ def _str_isupper(self):
         return self._convert_bool_result(result)
 
     def _str_contains(
-        self, pat, case: bool = True, flags: int = 0, na=None, regex: bool = True
+        self,
+        pat,
+        case: bool = True,
+        flags: int = 0,
+        na: Scalar | lib.NoDefault = lib.no_default,
+        regex: bool = True,
     ):
         if flags:
             raise NotImplementedError(f"contains not implemented with {flags=}")
@@ -293,19 +297,25 @@ def _str_contains(
         else:
             pa_contains = pc.match_substring
         result = pa_contains(self._pa_array, pat, ignore_case=not case)
-        if not isna(na):  # pyright: ignore [reportGeneralTypeIssues]
-            result = result.fill_null(na)
-        return self._convert_bool_result(result)
+        return self._convert_bool_result(result, na=na, method_name="contains")
 
     def _str_match(
-        self, pat: str, case: bool = True, flags: int = 0, na: Scalar | None = None
+        self,
+        pat: str,
+        case: bool = True,
+        flags: int = 0,
+        na: Scalar | lib.NoDefault = lib.no_default,
     ):
         if not pat.startswith("^"):
             pat = f"^{pat}"
         return self._str_contains(pat, case, flags, na, regex=True)
 
     def _str_fullmatch(
-        self, pat, case: bool = True, flags: int = 0, na: Scalar | None = None
+        self,
+        pat,
+        case: bool = True,
+        flags: int = 0,
+        na: Scalar | lib.NoDefault = lib.no_default,
     ):
         if not pat.endswith("$") or pat.endswith("\\$"):
             pat = f"{pat}$"
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 00d46ab9296d0..dab6a13ff3528 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -2318,7 +2318,9 @@ def _apply_elementwise(self, func: Callable) -> list[list[Any]]:
             for chunk in self._pa_array.iterchunks()
         ]
 
-    def _convert_bool_result(self, result):
+    def _convert_bool_result(self, result, na=lib.no_default, method_name=None):
+        if na is not lib.no_default and not isna(na):  # pyright: ignore [reportGeneralTypeIssues]
+            result = result.fill_null(na)
         return type(self)(result)
 
     def _convert_int_result(self, result):
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 0484ef89f61c2..7cde4c53cb2f5 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -2679,16 +2679,28 @@ def isin(self, values: ArrayLike) -> npt.NDArray[np.bool_]:
     # ------------------------------------------------------------------------
     # String methods interface
     def _str_map(
-        self, f, na_value=np.nan, dtype=np.dtype("object"), convert: bool = True
+        self, f, na_value=lib.no_default, dtype=np.dtype("object"), convert: bool = True
     ):
         # Optimization to apply the callable `f` to the categories once
         # and rebuild the result by `take`ing from the result with the codes.
         # Returns the same type as the object-dtype implementation though.
-        from pandas.core.arrays import NumpyExtensionArray
-
         categories = self.categories
         codes = self.codes
-        result = NumpyExtensionArray(categories.to_numpy())._str_map(f, na_value, dtype)
+        if categories.dtype == "string":
+            result = categories.array._str_map(f, na_value, dtype)  # type: ignore[attr-defined]
+            if (
+                categories.dtype.na_value is np.nan  # type: ignore[union-attr]
+                and is_bool_dtype(dtype)
+                and (na_value is lib.no_default or isna(na_value))
+            ):
+                # NaN propagates as False for functions with boolean return type
+                na_value = False
+        else:
+            from pandas.core.arrays import NumpyExtensionArray
+
+            result = NumpyExtensionArray(categories.to_numpy())._str_map(
+                f, na_value, dtype
+            )
         return take_nd(result, codes, fill_value=na_value)
 
     def _str_get_dummies(self, sep: str = "|", dtype: NpDtype | None = None):
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index e4daf9ed450fb..f20c4c8625475 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -381,7 +381,11 @@ def _from_scalars(cls, scalars, dtype: DtypeObj) -> Self:
         return cls._from_sequence(scalars, dtype=dtype)
 
     def _str_map(
-        self, f, na_value=None, dtype: Dtype | None = None, convert: bool = True
+        self,
+        f,
+        na_value=lib.no_default,
+        dtype: Dtype | None = None,
+        convert: bool = True,
     ):
         if self.dtype.na_value is np.nan:
             return self._str_map_nan_semantics(f, na_value=na_value, dtype=dtype)
@@ -390,7 +394,7 @@ def _str_map(
 
         if dtype is None:
             dtype = self.dtype
-        if na_value is None:
+        if na_value is lib.no_default:
             na_value = self.dtype.na_value
 
         mask = isna(self)
@@ -459,11 +463,17 @@ def _str_map_str_or_object(
             # -> We don't know the result type. E.g. `.get` can return anything.
             return lib.map_infer_mask(arr, f, mask.view("uint8"))
 
-    def _str_map_nan_semantics(self, f, na_value=None, dtype: Dtype | None = None):
+    def _str_map_nan_semantics(
+        self, f, na_value=lib.no_default, dtype: Dtype | None = None
+    ):
         if dtype is None:
             dtype = self.dtype
-        if na_value is None:
-            na_value = self.dtype.na_value
+        if na_value is lib.no_default:
+            if is_bool_dtype(dtype):
+                # NaN propagates as False
+                na_value = False
+            else:
+                na_value = self.dtype.na_value
 
         mask = isna(self)
         arr = np.asarray(self)
@@ -474,7 +484,8 @@ def _str_map_nan_semantics(self, f, na_value=None, dtype: Dtype | None = None):
                 if is_integer_dtype(dtype):
                     na_value = 0
                 else:
-                    na_value = True
+                    # NaN propagates as False
+                    na_value = False
 
             result = lib.map_infer_mask(
                 arr,
@@ -484,15 +495,13 @@ def _str_map_nan_semantics(self, f, na_value=None, dtype: Dtype | None = None):
                 na_value=na_value,
                 dtype=np.dtype(cast(type, dtype)),
             )
-            if na_value_is_na and mask.any():
+            if na_value_is_na and is_integer_dtype(dtype) and mask.any():
                 # TODO: we could alternatively do this check before map_infer_mask
                 #  and adjust the dtype/na_value we pass there. Which is more
                 #  performant?
-                if is_integer_dtype(dtype):
-                    result = result.astype("float64")
-                else:
-                    result = result.astype("object")
+                result = result.astype("float64")
                 result[mask] = np.nan
+
             return result
 
         else:
diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index 75bb1f8fb1a65..6066b8c73a23a 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -219,9 +219,27 @@ def insert(self, loc: int, item) -> ArrowStringArray:
             raise TypeError("Scalar must be NA or str")
         return super().insert(loc, item)
 
-    def _convert_bool_result(self, values):
+    def _convert_bool_result(self, values, na=lib.no_default, method_name=None):
+        if na is not lib.no_default and not isna(na) and not isinstance(na, bool):
+            # GH#59561
+            warnings.warn(
+                f"Allowing a non-bool 'na' in obj.str.{method_name} is deprecated "
+                "and will raise in a future version.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+            na = bool(na)
+
         if self.dtype.na_value is np.nan:
-            return ArrowExtensionArray(values).to_numpy(na_value=np.nan)
+            if na is lib.no_default or isna(na):
+                # NaN propagates as False
+                values = values.fill_null(False)
+            else:
+                values = values.fill_null(na)
+            return values.to_numpy()
+        else:
+            if na is not lib.no_default and not isna(na):  # pyright: ignore [reportGeneralTypeIssues]
+                values = values.fill_null(na)
         return BooleanDtype().__from_arrow__(values)
 
     def _maybe_convert_setitem_value(self, value):
@@ -306,22 +324,16 @@ def astype(self, dtype, copy: bool = True):
     _str_slice = ArrowStringArrayMixin._str_slice
 
     def _str_contains(
-        self, pat, case: bool = True, flags: int = 0, na=np.nan, regex: bool = True
+        self,
+        pat,
+        case: bool = True,
+        flags: int = 0,
+        na=lib.no_default,
+        regex: bool = True,
     ):
         if flags:
             return super()._str_contains(pat, case, flags, na, regex)
 
-        if not isna(na):
-            if not isinstance(na, bool):
-                # GH#59561
-                warnings.warn(
-                    "Allowing a non-bool 'na' in obj.str.contains is deprecated "
-                    "and will raise in a future version.",
-                    FutureWarning,
-                    stacklevel=find_stack_level(),
-                )
-                na = bool(na)
-
         return ArrowStringArrayMixin._str_contains(self, pat, case, flags, na, regex)
 
     def _str_replace(
diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py
index 10117aa6bf503..3cb0e75cfb815 100644
--- a/pandas/core/strings/accessor.py
+++ b/pandas/core/strings/accessor.py
@@ -1225,7 +1225,12 @@ def join(self, sep: str):
 
     @forbid_nonstring_types(["bytes"])
     def contains(
-        self, pat, case: bool = True, flags: int = 0, na=None, regex: bool = True
+        self,
+        pat,
+        case: bool = True,
+        flags: int = 0,
+        na=lib.no_default,
+        regex: bool = True,
     ):
         r"""
         Test if pattern or regex is contained within a string of a Series or Index.
@@ -1243,8 +1248,9 @@ def contains(
             Flags to pass through to the re module, e.g. re.IGNORECASE.
         na : scalar, optional
             Fill value for missing values. The default depends on dtype of the
-            array. For object-dtype, ``numpy.nan`` is used. For ``StringDtype``,
-            ``pandas.NA`` is used.
+            array. For object-dtype, ``numpy.nan`` is used. For the nullable
+            ``StringDtype``, ``pandas.NA`` is used. For the ``"str"`` dtype,
+            ``False`` is used.
         regex : bool, default True
             If True, assumes the pat is a regular expression.
 
@@ -1362,7 +1368,7 @@ def contains(
         return self._wrap_result(result, fill_value=na, returns_string=False)
 
     @forbid_nonstring_types(["bytes"])
-    def match(self, pat: str, case: bool = True, flags: int = 0, na=None):
+    def match(self, pat: str, case: bool = True, flags: int = 0, na=lib.no_default):
         """
         Determine if each string starts with a match of a regular expression.
 
@@ -1376,8 +1382,9 @@ def match(self, pat: str, case: bool = True, flags: int = 0, na=None):
             Regex module flags, e.g. re.IGNORECASE.
         na : scalar, optional
             Fill value for missing values. The default depends on dtype of the
-            array. For object-dtype, ``numpy.nan`` is used. For ``StringDtype``,
-            ``pandas.NA`` is used.
+            array. For object-dtype, ``numpy.nan`` is used. For the nullable
+            ``StringDtype``, ``pandas.NA`` is used. For the ``"str"`` dtype,
+            ``False`` is used.
 
         Returns
         -------
@@ -1406,7 +1413,7 @@ def match(self, pat: str, case: bool = True, flags: int = 0, na=None):
         return self._wrap_result(result, fill_value=na, returns_string=False)
 
     @forbid_nonstring_types(["bytes"])
-    def fullmatch(self, pat, case: bool = True, flags: int = 0, na=None):
+    def fullmatch(self, pat, case: bool = True, flags: int = 0, na=lib.no_default):
         """
         Determine if each string entirely matches a regular expression.
 
@@ -1420,8 +1427,9 @@ def fullmatch(self, pat, case: bool = True, flags: int = 0, na=None):
             Regex module flags, e.g. re.IGNORECASE.
         na : scalar, optional
             Fill value for missing values. The default depends on dtype of the
-            array. For object-dtype, ``numpy.nan`` is used. For ``StringDtype``,
-            ``pandas.NA`` is used.
+            array. For object-dtype, ``numpy.nan`` is used. For the nullable
+            ``StringDtype``, ``pandas.NA`` is used. For the ``"str"`` dtype,
+            ``False`` is used.
 
         Returns
         -------
@@ -2612,7 +2620,7 @@ def count(self, pat, flags: int = 0):
 
     @forbid_nonstring_types(["bytes"])
     def startswith(
-        self, pat: str | tuple[str, ...], na: Scalar | None = None
+        self, pat: str | tuple[str, ...], na: Scalar | lib.NoDefault = lib.no_default
     ) -> Series | Index:
         """
         Test if the start of each string element matches a pattern.
@@ -2624,10 +2632,11 @@ def startswith(
         pat : str or tuple[str, ...]
             Character sequence or tuple of strings. Regular expressions are not
             accepted.
-        na : object, default NaN
+        na : scalar, optional
             Object shown if element tested is not a string. The default depends
             on dtype of the array. For object-dtype, ``numpy.nan`` is used.
-            For ``StringDtype``, ``pandas.NA`` is used.
+            For the nullable ``StringDtype``, ``pandas.NA`` is used.
+            For the ``"str"`` dtype, ``False`` is used.
 
         Returns
         -------
@@ -2682,7 +2691,7 @@ def startswith(
 
     @forbid_nonstring_types(["bytes"])
     def endswith(
-        self, pat: str | tuple[str, ...], na: Scalar | None = None
+        self, pat: str | tuple[str, ...], na: Scalar | lib.NoDefault = lib.no_default
     ) -> Series | Index:
         """
         Test if the end of each string element matches a pattern.
@@ -2694,10 +2703,11 @@ def endswith(
         pat : str or tuple[str, ...]
             Character sequence or tuple of strings. Regular expressions are not
             accepted.
-        na : object, default NaN
+        na : scalar, optional
             Object shown if element tested is not a string. The default depends
             on dtype of the array. For object-dtype, ``numpy.nan`` is used.
-            For ``StringDtype``, ``pandas.NA`` is used.
+            For the nullable ``StringDtype``, ``pandas.NA`` is used.
+            For the ``"str"`` dtype, ``False`` is used.
 
         Returns
         -------
diff --git a/pandas/core/strings/base.py b/pandas/core/strings/base.py
index 97d906e3df077..4ed36f85167c9 100644
--- a/pandas/core/strings/base.py
+++ b/pandas/core/strings/base.py
@@ -6,7 +6,7 @@
     Literal,
 )
 
-import numpy as np
+from pandas._libs import lib
 
 if TYPE_CHECKING:
     from collections.abc import (
@@ -89,7 +89,11 @@ def _str_repeat(self, repeats: int | Sequence[int]):
 
     @abc.abstractmethod
     def _str_match(
-        self, pat: str, case: bool = True, flags: int = 0, na: Scalar = np.nan
+        self,
+        pat: str,
+        case: bool = True,
+        flags: int = 0,
+        na: Scalar | lib.NoDefault = lib.no_default,
     ):
         pass
 
@@ -99,7 +103,7 @@ def _str_fullmatch(
         pat: str | re.Pattern,
         case: bool = True,
         flags: int = 0,
-        na: Scalar = np.nan,
+        na: Scalar | lib.NoDefault = lib.no_default,
     ):
         pass
 
diff --git a/pandas/core/strings/object_array.py b/pandas/core/strings/object_array.py
index 6211c7b528db9..0268194e64d50 100644
--- a/pandas/core/strings/object_array.py
+++ b/pandas/core/strings/object_array.py
@@ -45,7 +45,11 @@ def __len__(self) -> int:
         raise NotImplementedError
 
     def _str_map(
-        self, f, na_value=None, dtype: NpDtype | None = None, convert: bool = True
+        self,
+        f,
+        na_value=lib.no_default,
+        dtype: NpDtype | None = None,
+        convert: bool = True,
     ):
         """
         Map a callable over valid elements of the array.
@@ -66,7 +70,7 @@ def _str_map(
         """
         if dtype is None:
             dtype = np.dtype("object")
-        if na_value is None:
+        if na_value is lib.no_default:
             na_value = self.dtype.na_value  # type: ignore[attr-defined]
 
         if not len(self):
@@ -130,7 +134,12 @@ def _str_pad(
         return self._str_map(f)
 
     def _str_contains(
-        self, pat, case: bool = True, flags: int = 0, na=np.nan, regex: bool = True
+        self,
+        pat,
+        case: bool = True,
+        flags: int = 0,
+        na=lib.no_default,
+        regex: bool = True,
     ):
         if regex:
             if not case:
@@ -145,7 +154,7 @@ def _str_contains(
             else:
                 upper_pat = pat.upper()
                 f = lambda x: upper_pat in x.upper()
-        if not isna(na) and not isinstance(na, bool):
+        if na is not lib.no_default and not isna(na) and not isinstance(na, bool):
             # GH#59561
             warnings.warn(
                 "Allowing a non-bool 'na' in obj.str.contains is deprecated "
@@ -155,9 +164,9 @@ def _str_contains(
             )
         return self._str_map(f, na, dtype=np.dtype("bool"))
 
-    def _str_startswith(self, pat, na=None):
+    def _str_startswith(self, pat, na=lib.no_default):
         f = lambda x: x.startswith(pat)
-        if not isna(na) and not isinstance(na, bool):
+        if na is not lib.no_default and not isna(na) and not isinstance(na, bool):
             # GH#59561
             warnings.warn(
                 "Allowing a non-bool 'na' in obj.str.startswith is deprecated "
@@ -167,9 +176,9 @@ def _str_startswith(self, pat, na=None):
             )
         return self._str_map(f, na_value=na, dtype=np.dtype(bool))
 
-    def _str_endswith(self, pat, na=None):
+    def _str_endswith(self, pat, na=lib.no_default):
         f = lambda x: x.endswith(pat)
-        if not isna(na) and not isinstance(na, bool):
+        if na is not lib.no_default and not isna(na) and not isinstance(na, bool):
             # GH#59561
             warnings.warn(
                 "Allowing a non-bool 'na' in obj.str.endswith is deprecated "
@@ -238,7 +247,11 @@ def rep(x, r):
             return type(self)._from_sequence(result, dtype=self.dtype)
 
     def _str_match(
-        self, pat: str, case: bool = True, flags: int = 0, na: Scalar | None = None
+        self,
+        pat: str,
+        case: bool = True,
+        flags: int = 0,
+        na: Scalar | lib.NoDefault = lib.no_default,
     ):
         if not case:
             flags |= re.IGNORECASE
@@ -253,7 +266,7 @@ def _str_fullmatch(
         pat: str | re.Pattern,
         case: bool = True,
         flags: int = 0,
-        na: Scalar | None = None,
+        na: Scalar | lib.NoDefault = lib.no_default,
     ):
         if not case:
             flags |= re.IGNORECASE
diff --git a/pandas/tests/strings/test_api.py b/pandas/tests/strings/test_api.py
index 2511474e03ff7..4a1b97606db2b 100644
--- a/pandas/tests/strings/test_api.py
+++ b/pandas/tests/strings/test_api.py
@@ -122,6 +122,7 @@ def test_api_per_method(
     any_allowed_skipna_inferred_dtype,
     any_string_method,
     request,
+    using_infer_string,
 ):
     # this test does not check correctness of the different methods,
     # just that the methods work on the specified (inferred) dtypes,
@@ -160,6 +161,10 @@ def test_api_per_method(
     t = box(values, dtype=dtype)  # explicit dtype to avoid casting
     method = getattr(t.str, method_name)
 
+    if using_infer_string and dtype == "category":
+        string_allowed = method_name not in ["decode"]
+    else:
+        string_allowed = True
     bytes_allowed = method_name in ["decode", "get", "len", "slice"]
     # as of v0.23.4, all methods except 'cat' are very lenient with the
     # allowed data types, just returning NaN for entries that error.
@@ -168,7 +173,8 @@ def test_api_per_method(
     mixed_allowed = method_name not in ["cat"]
 
     allowed_types = (
-        ["string", "unicode", "empty"]
+        ["empty"]
+        + ["string", "unicode"] * string_allowed
         + ["bytes"] * bytes_allowed
         + ["mixed", "mixed-integer"] * mixed_allowed
     )
@@ -182,6 +188,7 @@ def test_api_per_method(
         msg = (
             f"Cannot use .str.{method_name} with values of "
             f"inferred dtype {inferred_dtype!r}."
+            "|a bytes-like object is required, not 'str'"
         )
         with pytest.raises(TypeError, match=msg):
             method(*args, **kwargs)
diff --git a/pandas/tests/strings/test_find_replace.py b/pandas/tests/strings/test_find_replace.py
index f3698a2ea33cf..34a6377b5786f 100644
--- a/pandas/tests/strings/test_find_replace.py
+++ b/pandas/tests/strings/test_find_replace.py
@@ -29,20 +29,28 @@ def test_contains(any_string_dtype):
     pat = "mmm[_]+"
 
     result = values.str.contains(pat)
-    expected_dtype = (
-        "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
-    )
-    expected = Series(
-        np.array([False, np.nan, True, True, False], dtype=np.object_),
-        dtype=expected_dtype,
-    )
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected = Series([False, False, True, True, False], dtype=bool)
+    else:
+        expected_dtype = (
+            "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
+        )
+        expected = Series(
+            np.array([False, np.nan, True, True, False], dtype=np.object_),
+            dtype=expected_dtype,
+        )
+
     tm.assert_series_equal(result, expected)
 
     result = values.str.contains(pat, regex=False)
-    expected = Series(
-        np.array([False, np.nan, False, False, True], dtype=np.object_),
-        dtype=expected_dtype,
-    )
+    if any_string_dtype == "str":
+        expected = Series([False, False, False, False, True], dtype=bool)
+    else:
+        expected = Series(
+            np.array([False, np.nan, False, False, True], dtype=np.object_),
+            dtype=expected_dtype,
+        )
     tm.assert_series_equal(result, expected)
 
     values = Series(
@@ -79,12 +87,16 @@ def test_contains(any_string_dtype):
     pat = "mmm[_]+"
 
     result = values.str.contains(pat)
-    expected_dtype = (
-        "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
-    )
-    expected = Series(
-        np.array([False, np.nan, True, True], dtype=np.object_), dtype=expected_dtype
-    )
+    if any_string_dtype == "str":
+        expected = Series([False, False, True, True], dtype=bool)
+    else:
+        expected_dtype = (
+            "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
+        )
+        expected = Series(
+            np.array([False, np.nan, True, True], dtype=np.object_),
+            dtype=expected_dtype,
+        )
     tm.assert_series_equal(result, expected)
 
     result = values.str.contains(pat, na=False)
@@ -184,39 +196,45 @@ def test_contains_moar(any_string_dtype):
     )
 
     result = s.str.contains("a")
-    expected_dtype = (
-        "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
-    )
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected_dtype = bool
+        na_value = False
+    else:
+        expected_dtype = (
+            "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
+        )
+        na_value = np.nan
     expected = Series(
-        [False, False, False, True, True, False, np.nan, False, False, True],
+        [False, False, False, True, True, False, na_value, False, False, True],
         dtype=expected_dtype,
     )
     tm.assert_series_equal(result, expected)
 
     result = s.str.contains("a", case=False)
     expected = Series(
-        [True, False, False, True, True, False, np.nan, True, False, True],
+        [True, False, False, True, True, False, na_value, True, False, True],
         dtype=expected_dtype,
     )
     tm.assert_series_equal(result, expected)
 
     result = s.str.contains("Aa")
     expected = Series(
-        [False, False, False, True, False, False, np.nan, False, False, False],
+        [False, False, False, True, False, False, na_value, False, False, False],
         dtype=expected_dtype,
     )
     tm.assert_series_equal(result, expected)
 
     result = s.str.contains("ba")
     expected = Series(
-        [False, False, False, True, False, False, np.nan, False, False, False],
+        [False, False, False, True, False, False, na_value, False, False, False],
         dtype=expected_dtype,
     )
     tm.assert_series_equal(result, expected)
 
     result = s.str.contains("ba", case=False)
     expected = Series(
-        [False, False, False, True, True, False, np.nan, True, False, False],
+        [False, False, False, True, True, False, na_value, True, False, False],
         dtype=expected_dtype,
     )
     tm.assert_series_equal(result, expected)
@@ -252,10 +270,14 @@ def test_contains_nan(any_string_dtype):
     tm.assert_series_equal(result, expected)
 
     result = s.str.contains("foo")
-    expected_dtype = (
-        "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
-    )
-    expected = Series([np.nan, np.nan, np.nan], dtype=expected_dtype)
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected = Series([False, False, False], dtype=bool)
+    else:
+        expected_dtype = (
+            "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
+        )
+        expected = Series([np.nan, np.nan, np.nan], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
 
@@ -272,9 +294,7 @@ def test_startswith_endswith_validate_na(any_string_dtype):
     )
 
     dtype = ser.dtype
-    if (
-        isinstance(dtype, pd.StringDtype) and dtype.storage == "python"
-    ) or dtype == np.dtype("object"):
+    if (isinstance(dtype, pd.StringDtype)) or dtype == np.dtype("object"):
         msg = "Allowing a non-bool 'na' in obj.str.startswith is deprecated"
         with tm.assert_produces_warning(FutureWarning, match=msg):
             ser.str.startswith("kapow", na="baz")
@@ -296,7 +316,7 @@ def test_startswith_endswith_validate_na(any_string_dtype):
 @pytest.mark.parametrize("dtype", ["object", "category"])
 @pytest.mark.parametrize("null_value", [None, np.nan, pd.NA])
 @pytest.mark.parametrize("na", [True, False])
-def test_startswith(pat, dtype, null_value, na):
+def test_startswith(pat, dtype, null_value, na, using_infer_string):
     # add category dtype parametrizations for GH-36241
     values = Series(
         ["om", null_value, "foo_nom", "nom", "bar_foo", null_value, "foo"],
@@ -310,6 +330,8 @@ def test_startswith(pat, dtype, null_value, na):
         exp = exp.fillna(null_value)
     elif dtype == "object" and null_value is None:
         exp[exp.isna()] = None
+    elif using_infer_string and dtype == "category":
+        exp = exp.fillna(False).astype(bool)
     tm.assert_series_equal(result, exp)
 
     result = values.str.startswith(pat, na=na)
@@ -327,20 +349,31 @@ def test_startswith(pat, dtype, null_value, na):
 
 
 @pytest.mark.parametrize("na", [None, True, False])
-def test_startswith_nullable_string_dtype(nullable_string_dtype, na):
+def test_startswith_string_dtype(any_string_dtype, na):
     values = Series(
         ["om", None, "foo_nom", "nom", "bar_foo", None, "foo", "regex", "rege."],
-        dtype=nullable_string_dtype,
+        dtype=any_string_dtype,
     )
     result = values.str.startswith("foo", na=na)
+
+    expected_dtype = (
+        (object if na is None else bool)
+        if is_object_or_nan_string_dtype(any_string_dtype)
+        else "boolean"
+    )
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected_dtype = bool
+        if na is None:
+            na = False
     exp = Series(
-        [False, na, True, False, False, na, True, False, False], dtype="boolean"
+        [False, na, True, False, False, na, True, False, False], dtype=expected_dtype
     )
     tm.assert_series_equal(result, exp)
 
     result = values.str.startswith("rege.", na=na)
     exp = Series(
-        [False, na, False, False, False, na, False, False, True], dtype="boolean"
+        [False, na, False, False, False, na, False, False, True], dtype=expected_dtype
     )
     tm.assert_series_equal(result, exp)
 
@@ -354,7 +387,7 @@ def test_startswith_nullable_string_dtype(nullable_string_dtype, na):
 @pytest.mark.parametrize("dtype", ["object", "category"])
 @pytest.mark.parametrize("null_value", [None, np.nan, pd.NA])
 @pytest.mark.parametrize("na", [True, False])
-def test_endswith(pat, dtype, null_value, na):
+def test_endswith(pat, dtype, null_value, na, using_infer_string):
     # add category dtype parametrizations for GH-36241
     values = Series(
         ["om", null_value, "foo_nom", "nom", "bar_foo", null_value, "foo"],
@@ -368,6 +401,8 @@ def test_endswith(pat, dtype, null_value, na):
         exp = exp.fillna(null_value)
     elif dtype == "object" and null_value is None:
         exp[exp.isna()] = None
+    elif using_infer_string and dtype == "category":
+        exp = exp.fillna(False).astype(bool)
     tm.assert_series_equal(result, exp)
 
     result = values.str.endswith(pat, na=na)
@@ -385,20 +420,30 @@ def test_endswith(pat, dtype, null_value, na):
 
 
 @pytest.mark.parametrize("na", [None, True, False])
-def test_endswith_nullable_string_dtype(nullable_string_dtype, na):
+def test_endswith_string_dtype(any_string_dtype, na):
     values = Series(
         ["om", None, "foo_nom", "nom", "bar_foo", None, "foo", "regex", "rege."],
-        dtype=nullable_string_dtype,
+        dtype=any_string_dtype,
     )
     result = values.str.endswith("foo", na=na)
+    expected_dtype = (
+        (object if na is None else bool)
+        if is_object_or_nan_string_dtype(any_string_dtype)
+        else "boolean"
+    )
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected_dtype = bool
+        if na is None:
+            na = False
     exp = Series(
-        [False, na, False, False, True, na, True, False, False], dtype="boolean"
+        [False, na, False, False, True, na, True, False, False], dtype=expected_dtype
     )
     tm.assert_series_equal(result, exp)
 
     result = values.str.endswith("rege.", na=na)
     exp = Series(
-        [False, na, False, False, False, na, False, False, True], dtype="boolean"
+        [False, na, False, False, False, na, False, False, True], dtype=expected_dtype
     )
     tm.assert_series_equal(result, exp)
 
@@ -690,36 +735,41 @@ def test_replace_regex_single_character(regex, any_string_dtype):
 
 
 def test_match(any_string_dtype):
-    # New match behavior introduced in 0.13
-    expected_dtype = (
-        "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
-    )
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected_dtype = bool
+        na_value = False
+    else:
+        expected_dtype = (
+            "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
+        )
+        na_value = np.nan
 
     values = Series(["fooBAD__barBAD", np.nan, "foo"], dtype=any_string_dtype)
     result = values.str.match(".*(BAD[_]+).*(BAD)")
-    expected = Series([True, np.nan, False], dtype=expected_dtype)
+    expected = Series([True, na_value, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
     values = Series(
         ["fooBAD__barBAD", "BAD_BADleroybrown", np.nan, "foo"], dtype=any_string_dtype
     )
     result = values.str.match(".*BAD[_]+.*BAD")
-    expected = Series([True, True, np.nan, False], dtype=expected_dtype)
+    expected = Series([True, True, na_value, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
     result = values.str.match("BAD[_]+.*BAD")
-    expected = Series([False, True, np.nan, False], dtype=expected_dtype)
+    expected = Series([False, True, na_value, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
     values = Series(
         ["fooBAD__barBAD", "^BAD_BADleroybrown", np.nan, "foo"], dtype=any_string_dtype
     )
     result = values.str.match("^BAD[_]+.*BAD")
-    expected = Series([False, False, np.nan, False], dtype=expected_dtype)
+    expected = Series([False, False, na_value, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
     result = values.str.match("\\^BAD[_]+.*BAD")
-    expected = Series([False, True, np.nan, False], dtype=expected_dtype)
+    expected = Series([False, True, na_value, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
 
@@ -755,10 +805,17 @@ def test_match_na_kwarg(any_string_dtype):
     tm.assert_series_equal(result, expected)
 
     result = s.str.match("a")
-    expected_dtype = (
-        "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
-    )
-    expected = Series([True, False, np.nan], dtype=expected_dtype)
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected_dtype = bool
+        na_value = False
+    else:
+        expected_dtype = (
+            "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
+        )
+        na_value = np.nan
+
+    expected = Series([True, False, na_value], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
 
@@ -783,10 +840,14 @@ def test_fullmatch(any_string_dtype):
         ["fooBAD__barBAD", "BAD_BADleroybrown", np.nan, "foo"], dtype=any_string_dtype
     )
     result = ser.str.fullmatch(".*BAD[_]+.*BAD")
-    expected_dtype = (
-        "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
-    )
-    expected = Series([True, False, np.nan, False], dtype=expected_dtype)
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected = Series([True, False, False, False], dtype=bool)
+    else:
+        expected_dtype = (
+            "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
+        )
+        expected = Series([True, False, np.nan, False], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
 
@@ -794,10 +855,14 @@ def test_fullmatch_dollar_literal(any_string_dtype):
     # GH 56652
     ser = Series(["foo", "foo$foo", np.nan, "foo$"], dtype=any_string_dtype)
     result = ser.str.fullmatch("foo\\$")
-    expected_dtype = (
-        "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
-    )
-    expected = Series([False, False, np.nan, True], dtype=expected_dtype)
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected = Series([False, False, False, True], dtype=bool)
+    else:
+        expected_dtype = (
+            "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
+        )
+        expected = Series([False, False, np.nan, True], dtype=expected_dtype)
     tm.assert_series_equal(result, expected)
 
 
diff --git a/pandas/tests/strings/test_string_array.py b/pandas/tests/strings/test_string_array.py
index 517ddb164985c..cd3c512328139 100644
--- a/pandas/tests/strings/test_string_array.py
+++ b/pandas/tests/strings/test_string_array.py
@@ -38,7 +38,7 @@ def test_string_array(nullable_string_dtype, any_string_method):
             expected.values, skipna=True
         ):
             assert result.dtype == "boolean"
-            result = result.astype(object)
+            expected = expected.astype("boolean")
 
         elif expected.dtype == "bool":
             assert result.dtype == "boolean"
diff --git a/pandas/tests/strings/test_strings.py b/pandas/tests/strings/test_strings.py
index 4995b448f7e94..75a2007b61640 100644
--- a/pandas/tests/strings/test_strings.py
+++ b/pandas/tests/strings/test_strings.py
@@ -217,8 +217,21 @@ def test_ismethods(method, expected, any_string_dtype):
     tm.assert_series_equal(result, expected)
 
     # compare with standard library
-    expected = [getattr(item, method)() for item in ser]
-    assert list(result) == expected
+    expected_stdlib = [getattr(item, method)() for item in ser]
+    assert list(result) == expected_stdlib
+
+    # with missing value
+    ser.iloc[[1, 2, 3, 4]] = np.nan
+    result = getattr(ser.str, method)()
+    if ser.dtype == "object":
+        expected = expected.astype(object)
+        expected.iloc[[1, 2, 3, 4]] = np.nan
+    elif ser.dtype == "str":
+        # NaN propagates as False
+        expected.iloc[[1, 2, 3, 4]] = False
+    else:
+        # nullable dtypes propagate NaN
+        expected.iloc[[1, 2, 3, 4]] = np.nan
 
 
 @pytest.mark.parametrize(
@@ -259,10 +272,14 @@ def test_isnumeric_unicode(method, expected, any_string_dtype):
 def test_isnumeric_unicode_missing(method, expected, any_string_dtype):
     values = ["A", np.nan, "¼", "★", np.nan, "３", "four"]  # noqa: RUF001
     ser = Series(values, dtype=any_string_dtype)
-    expected_dtype = (
-        "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
-    )
-    expected = Series(expected, dtype=expected_dtype)
+    if any_string_dtype == "str":
+        # NaN propagates as False
+        expected = Series(expected, dtype=object).fillna(False).astype(bool)
+    else:
+        expected_dtype = (
+            "object" if is_object_or_nan_string_dtype(any_string_dtype) else "boolean"
+        )
+        expected = Series(expected, dtype=expected_dtype)
     result = getattr(ser.str, method)()
     tm.assert_series_equal(result, expected)
 

From 4f328f08df90906198b3a3f955ab321018964f0a Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Thu, 10 Oct 2024 15:19:55 +0200
Subject: [PATCH 15/20] TST (string dtype): resolve all infer_string
 TODO/xfails in pandas/tests/arrays (#59686)

---
 pandas/core/arrays/string_arrow.py            |  6 +++++-
 .../arrays/categorical/test_analytics.py      | 20 +++++++++----------
 pandas/tests/arrays/integer/test_reduction.py |  7 +------
 3 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index 6066b8c73a23a..9e9893ecbbd97 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -427,9 +427,13 @@ def _reduce(
                 arr = pc.or_kleene(nas, pc.not_equal(self._pa_array, ""))
             else:
                 arr = pc.not_equal(self._pa_array, "")
-            return ArrowExtensionArray(arr)._reduce(
+            result = ArrowExtensionArray(arr)._reduce(
                 name, skipna=skipna, keepdims=keepdims, **kwargs
             )
+            if keepdims:
+                # ArrowExtensionArray will return a length-1 bool[pyarrow] array
+                return result.astype(np.bool_)
+            return result
 
         result = self._reduce_calc(name, skipna=skipna, keepdims=keepdims, **kwargs)
         if name in ("argmin", "argmax") and isinstance(result, pa.Array):
diff --git a/pandas/tests/arrays/categorical/test_analytics.py b/pandas/tests/arrays/categorical/test_analytics.py
index 52fd80cd196e0..47fa354e12393 100644
--- a/pandas/tests/arrays/categorical/test_analytics.py
+++ b/pandas/tests/arrays/categorical/test_analytics.py
@@ -4,12 +4,7 @@
 import numpy as np
 import pytest
 
-from pandas._config import using_string_dtype
-
-from pandas.compat import (
-    HAS_PYARROW,
-    PYPY,
-)
+from pandas.compat import PYPY
 
 from pandas import (
     Categorical,
@@ -299,10 +294,7 @@ def test_nbytes(self):
         exp = 3 + 3 * 8  # 3 int8s for values + 3 int64s for categories
         assert cat.nbytes == exp
 
-    @pytest.mark.xfail(
-        using_string_dtype() and HAS_PYARROW, reason="TODO(infer_string)"
-    )
-    def test_memory_usage(self):
+    def test_memory_usage(self, using_infer_string):
         cat = Categorical([1, 2, 3])
 
         # .categories is an index, so we include the hashtable
@@ -310,7 +302,13 @@ def test_memory_usage(self):
         assert 0 < cat.nbytes <= cat.memory_usage(deep=True)
 
         cat = Categorical(["foo", "foo", "bar"])
-        assert cat.memory_usage(deep=True) > cat.nbytes
+        if using_infer_string:
+            if cat.categories.dtype.storage == "python":
+                assert cat.memory_usage(deep=True) > cat.nbytes
+            else:
+                assert cat.memory_usage(deep=True) >= cat.nbytes
+        else:
+            assert cat.memory_usage(deep=True) > cat.nbytes
 
         if not PYPY:
             # sys.getsizeof will call the .memory_usage with
diff --git a/pandas/tests/arrays/integer/test_reduction.py b/pandas/tests/arrays/integer/test_reduction.py
index e485c7f79b475..1c91cd25ba69c 100644
--- a/pandas/tests/arrays/integer/test_reduction.py
+++ b/pandas/tests/arrays/integer/test_reduction.py
@@ -1,8 +1,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import HAS_PYARROW
-
 import pandas as pd
 from pandas import (
     DataFrame,
@@ -104,10 +102,7 @@ def test_groupby_reductions(op, expected):
         ["all", Series([True, True, True], index=["A", "B", "C"], dtype="boolean")],
     ],
 )
-def test_mixed_reductions(request, op, expected, using_infer_string):
-    if op in ["any", "all"] and using_infer_string and HAS_PYARROW:
-        # TODO(infer_string) inconsistent result type
-        request.applymarker(pytest.mark.xfail(reason="TODO(infer_string)"))
+def test_mixed_reductions(op, expected):
     df = DataFrame(
         {
             "A": ["a", "b", "b"],

From 97c4ce390ae7dafb7f58a21184cc32d921edb6c6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 10 Oct 2024 11:02:14 -0700
Subject: [PATCH 16/20] Bump pypa/cibuildwheel from 2.20.0 to 2.21.0 (#59816)

Bumps [pypa/cibuildwheel](https://github.com/pypa/cibuildwheel) from 2.20.0 to 2.21.0.
- [Release notes](https://github.com/pypa/cibuildwheel/releases)
- [Changelog](https://github.com/pypa/cibuildwheel/blob/main/docs/changelog.md)
- [Commits](https://github.com/pypa/cibuildwheel/compare/v2.20.0...v2.21.0)

---
updated-dependencies:
- dependency-name: pypa/cibuildwheel
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Thomas Li <47963215+lithomas1@users.noreply.github.com>
Co-authored-by: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
---
 .github/workflows/wheels.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index de59a454c827c..ce48cfa463974 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -156,7 +156,7 @@ jobs:
         run: echo "sdist_name=$(cd ./dist && ls -d */)" >> "$GITHUB_ENV"
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v2.20.0
+        uses: pypa/cibuildwheel@v2.21.0
         with:
          package-dir: ./dist/${{ startsWith(matrix.buildplat[1], 'macosx') && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
         env:

From 2b9ca0734ead966146321fa22d009d5eb186eb0b Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Thu, 10 Oct 2024 12:15:00 -1000
Subject: [PATCH 17/20] STY: Bump pyright, pyupgrade and mypy for new PEP-696
 syntax (#60006)

* STY: Bump pyright, pyupgrade and mypy for new PEP-696 syntax

* Apply update

* fix & ignore failures

* another ignore
---
 .pre-commit-config.yaml                  |  4 ++--
 environment.yml                          |  6 +++---
 pandas/_config/config.py                 |  4 ++--
 pandas/_config/localization.py           |  2 +-
 pandas/_testing/_warnings.py             |  2 +-
 pandas/_testing/contexts.py              |  8 ++++----
 pandas/compat/pickle_compat.py           |  2 +-
 pandas/core/apply.py                     | 12 ++++--------
 pandas/core/arraylike.py                 |  4 ++--
 pandas/core/arrays/arrow/array.py        |  2 +-
 pandas/core/arrays/boolean.py            |  2 +-
 pandas/core/arrays/datetimes.py          |  2 +-
 pandas/core/common.py                    |  4 +---
 pandas/core/computation/expr.py          |  2 +-
 pandas/core/frame.py                     |  2 +-
 pandas/core/groupby/groupby.py           |  8 +++++---
 pandas/core/groupby/ops.py               |  2 +-
 pandas/core/indexes/interval.py          |  4 ++--
 pandas/core/indexes/multi.py             |  2 +-
 pandas/core/internals/blocks.py          |  2 +-
 pandas/core/internals/concat.py          |  2 +-
 pandas/core/internals/managers.py        |  4 ++--
 pandas/core/methods/to_dict.py           |  2 +-
 pandas/core/resample.py                  |  2 +-
 pandas/core/series.py                    |  3 +--
 pandas/core/tools/datetimes.py           |  2 +-
 pandas/core/window/rolling.py            |  2 +-
 pandas/io/excel/_odswriter.py            |  2 +-
 pandas/io/excel/_openpyxl.py             |  2 +-
 pandas/io/excel/_xlsxwriter.py           |  2 +-
 pandas/io/formats/css.py                 | 10 +++-------
 pandas/io/formats/format.py              |  2 +-
 pandas/io/parsers/python_parser.py       |  2 +-
 pandas/io/sas/sas7bdat.py                |  2 +-
 pandas/io/sql.py                         | 12 ++++++------
 pandas/plotting/_matplotlib/converter.py |  8 ++++----
 pandas/plotting/_matplotlib/tools.py     |  2 +-
 pandas/plotting/_misc.py                 |  2 +-
 pandas/tests/frame/test_ufunc.py         |  4 ++--
 pandas/tests/indexes/test_base.py        |  2 +-
 pandas/util/_exceptions.py               | 11 +++++++----
 requirements-dev.txt                     |  6 +++---
 42 files changed, 78 insertions(+), 84 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 7c9ebf7d94173..1cb7b288aba69 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -74,7 +74,7 @@ repos:
     hooks:
     -   id: isort
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v3.16.0
+    rev: v3.17.0
     hooks:
     -   id: pyupgrade
         args: [--py310-plus]
@@ -112,7 +112,7 @@ repos:
         types: [python]
         stages: [manual]
         additional_dependencies: &pyright_dependencies
-        - pyright@1.1.352
+        - pyright@1.1.383
     -   id: pyright
         # note: assumes python env is setup and activated
         name: pyright reportGeneralTypeIssues
diff --git a/environment.yml b/environment.yml
index 34bc0591ca8df..ab834735441f0 100644
--- a/environment.yml
+++ b/environment.yml
@@ -76,10 +76,10 @@ dependencies:
   - cxx-compiler
 
   # code checks
-  - flake8=6.1.0  # run in subprocess over docstring examples
-  - mypy=1.9.0  # pre-commit uses locally installed mypy
+  - flake8=7.1.0  # run in subprocess over docstring examples
+  - mypy=1.11.2  # pre-commit uses locally installed mypy
   - tokenize-rt  # scripts/check_for_inconsistent_pandas_namespace.py
-  - pre-commit>=3.6.0
+  - pre-commit>=4.0.1
 
   # documentation
   - gitpython  # obtain contributors from git for whatsnew
diff --git a/pandas/_config/config.py b/pandas/_config/config.py
index 4ed2d4c3be692..25760df6bd7a4 100644
--- a/pandas/_config/config.py
+++ b/pandas/_config/config.py
@@ -411,7 +411,7 @@ def __dir__(self) -> list[str]:
 
 
 @contextmanager
-def option_context(*args) -> Generator[None, None, None]:
+def option_context(*args) -> Generator[None]:
     """
     Context manager to temporarily set options in a ``with`` statement.
 
@@ -718,7 +718,7 @@ def _build_option_description(k: str) -> str:
 
 
 @contextmanager
-def config_prefix(prefix: str) -> Generator[None, None, None]:
+def config_prefix(prefix: str) -> Generator[None]:
     """
     contextmanager for multiple invocations of API with a common prefix
 
diff --git a/pandas/_config/localization.py b/pandas/_config/localization.py
index 61d88c43f0e4a..6602633f20399 100644
--- a/pandas/_config/localization.py
+++ b/pandas/_config/localization.py
@@ -25,7 +25,7 @@
 @contextmanager
 def set_locale(
     new_locale: str | tuple[str, str], lc_var: int = locale.LC_ALL
-) -> Generator[str | tuple[str, str], None, None]:
+) -> Generator[str | tuple[str, str]]:
     """
     Context manager for temporarily setting a locale.
 
diff --git a/pandas/_testing/_warnings.py b/pandas/_testing/_warnings.py
index cd2e2b4141ffd..a752c8db90f38 100644
--- a/pandas/_testing/_warnings.py
+++ b/pandas/_testing/_warnings.py
@@ -35,7 +35,7 @@ def assert_produces_warning(
     raise_on_extra_warnings: bool = True,
     match: str | tuple[str | None, ...] | None = None,
     must_find_all_warnings: bool = True,
-) -> Generator[list[warnings.WarningMessage], None, None]:
+) -> Generator[list[warnings.WarningMessage]]:
     """
     Context manager for running code expected to either raise a specific warning,
     multiple specific warnings, or not raise any warnings. Verifies that the code
diff --git a/pandas/_testing/contexts.py b/pandas/_testing/contexts.py
index 4ca67d6fc082d..99826de51e1bf 100644
--- a/pandas/_testing/contexts.py
+++ b/pandas/_testing/contexts.py
@@ -29,7 +29,7 @@
 @contextmanager
 def decompress_file(
     path: FilePath | BaseBuffer, compression: CompressionOptions
-) -> Generator[IO[bytes], None, None]:
+) -> Generator[IO[bytes]]:
     """
     Open a compressed file and return a file object.
 
@@ -50,7 +50,7 @@ def decompress_file(
 
 
 @contextmanager
-def set_timezone(tz: str) -> Generator[None, None, None]:
+def set_timezone(tz: str) -> Generator[None]:
     """
     Context manager for temporarily setting a timezone.
 
@@ -92,7 +92,7 @@ def setTZ(tz) -> None:
 
 
 @contextmanager
-def ensure_clean(filename=None) -> Generator[Any, None, None]:
+def ensure_clean(filename=None) -> Generator[Any]:
     """
     Gets a temporary path and agrees to remove on close.
 
@@ -124,7 +124,7 @@ def ensure_clean(filename=None) -> Generator[Any, None, None]:
 
 
 @contextmanager
-def with_csv_dialect(name: str, **kwargs) -> Generator[None, None, None]:
+def with_csv_dialect(name: str, **kwargs) -> Generator[None]:
     """
     Context manager to temporarily register a CSV dialect for parsing CSV.
 
diff --git a/pandas/compat/pickle_compat.py b/pandas/compat/pickle_compat.py
index 28985a1380bee..beaaa3f8ed3cc 100644
--- a/pandas/compat/pickle_compat.py
+++ b/pandas/compat/pickle_compat.py
@@ -131,7 +131,7 @@ def loads(
 
 
 @contextlib.contextmanager
-def patch_pickle() -> Generator[None, None, None]:
+def patch_pickle() -> Generator[None]:
     """
     Temporarily patch pickle to use our unpickler.
     """
diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index 1f13459724d78..af2d6243ce4ed 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -246,12 +246,8 @@ def transform(self) -> DataFrame | Series:
             and not obj.empty
         ):
             raise ValueError("Transform function failed")
-        # error: Argument 1 to "__get__" of "AxisProperty" has incompatible type
-        # "Union[Series, DataFrame, GroupBy[Any], SeriesGroupBy,
-        # DataFrameGroupBy, BaseWindow, Resampler]"; expected "Union[DataFrame,
-        # Series]"
         if not isinstance(result, (ABCSeries, ABCDataFrame)) or not result.index.equals(
-            obj.index  # type: ignore[arg-type]
+            obj.index
         ):
             raise ValueError("Function did not transform")
 
@@ -803,7 +799,7 @@ def result_columns(self) -> Index:
 
     @property
     @abc.abstractmethod
-    def series_generator(self) -> Generator[Series, None, None]:
+    def series_generator(self) -> Generator[Series]:
         pass
 
     @staticmethod
@@ -1128,7 +1124,7 @@ class FrameRowApply(FrameApply):
     axis: AxisInt = 0
 
     @property
-    def series_generator(self) -> Generator[Series, None, None]:
+    def series_generator(self) -> Generator[Series]:
         return (self.obj._ixs(i, axis=1) for i in range(len(self.columns)))
 
     @staticmethod
@@ -1235,7 +1231,7 @@ def apply_broadcast(self, target: DataFrame) -> DataFrame:
         return result.T
 
     @property
-    def series_generator(self) -> Generator[Series, None, None]:
+    def series_generator(self) -> Generator[Series]:
         values = self.values
         values = ensure_wrapped_if_datetimelike(values)
         assert len(values) > 0
diff --git a/pandas/core/arraylike.py b/pandas/core/arraylike.py
index f70bb0743aa0f..43ac69508d1a4 100644
--- a/pandas/core/arraylike.py
+++ b/pandas/core/arraylike.py
@@ -403,12 +403,12 @@ def _reconstruct(result):
             # for np.<ufunc>(..) calls
             # kwargs cannot necessarily be handled block-by-block, so only
             # take this path if there are no kwargs
-            mgr = inputs[0]._mgr
+            mgr = inputs[0]._mgr  # pyright: ignore[reportGeneralTypeIssues]
             result = mgr.apply(getattr(ufunc, method))
         else:
             # otherwise specific ufunc methods (eg np.<ufunc>.accumulate(..))
             # Those can have an axis keyword and thus can't be called block-by-block
-            result = default_array_ufunc(inputs[0], ufunc, method, *inputs, **kwargs)
+            result = default_array_ufunc(inputs[0], ufunc, method, *inputs, **kwargs)  # pyright: ignore[reportGeneralTypeIssues]
             # e.g. np.negative (only one reached), with "where" and "out" in kwargs
 
     result = reconstruct(result)
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index dab6a13ff3528..619e7b3ccfb4f 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -2428,7 +2428,7 @@ def _str_rindex(self, sub: str, start: int = 0, end: int | None = None) -> Self:
         result = self._apply_elementwise(predicate)
         return type(self)(pa.chunked_array(result))
 
-    def _str_normalize(self, form: str) -> Self:
+    def _str_normalize(self, form: Literal["NFC", "NFD", "NFKC", "NFKD"]) -> Self:
         predicate = lambda val: unicodedata.normalize(form, val)
         result = self._apply_elementwise(predicate)
         return type(self)(pa.chunked_array(result))
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index 53ebc35b68d14..87c18fe346c62 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -369,7 +369,7 @@ def _coerce_to_array(
             assert dtype == "boolean"
         return coerce_to_array(value, copy=copy)
 
-    def _logical_method(self, other, op):
+    def _logical_method(self, other, op):  # type: ignore[override]
         assert op.__name__ in {"or_", "ror_", "and_", "rand_", "xor", "rxor"}
         other_is_scalar = lib.is_scalar(other)
         mask = None
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 41128e52e31b3..43cc492f82885 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -2918,7 +2918,7 @@ def _generate_range(
     offset: BaseOffset,
     *,
     unit: str,
-) -> Generator[Timestamp, None, None]:
+) -> Generator[Timestamp]:
     """
     Generates a sequence of dates corresponding to the specified time
     offset. Similar to dateutil.rrule except uses pandas DateOffset
diff --git a/pandas/core/common.py b/pandas/core/common.py
index ec0473a20458b..9788ec972ba1b 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -560,9 +560,7 @@ def convert_to_list_like(
 
 
 @contextlib.contextmanager
-def temp_setattr(
-    obj, attr: str, value, condition: bool = True
-) -> Generator[None, None, None]:
+def temp_setattr(obj, attr: str, value, condition: bool = True) -> Generator[None]:
     """
     Temporarily set attribute on an object.
 
diff --git a/pandas/core/computation/expr.py b/pandas/core/computation/expr.py
index f45bc453d2541..7025d8a72e561 100644
--- a/pandas/core/computation/expr.py
+++ b/pandas/core/computation/expr.py
@@ -168,7 +168,7 @@ def _preparse(
     the ``tokenize`` module and ``tokval`` is a string.
     """
     assert callable(f), "f must be callable"
-    return tokenize.untokenize(f(x) for x in tokenize_string(source))
+    return tokenize.untokenize(f(x) for x in tokenize_string(source))  # pyright: ignore[reportArgumentType]
 
 
 def _is_type(t):
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 1b47002e72fc6..24a164aa15427 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -2306,7 +2306,7 @@ def maybe_reorder(
 
         if any(exclude):
             arr_exclude = (x for x in exclude if x in arr_columns)
-            to_remove = {arr_columns.get_loc(col) for col in arr_exclude}
+            to_remove = {arr_columns.get_loc(col) for col in arr_exclude}  # pyright: ignore[reportUnhashable]
             arrays = [v for i, v in enumerate(arrays) if i not in to_remove]
 
             columns = columns.drop(exclude)
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 68314567d1b5e..5bf3e0e4de2fb 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -3719,7 +3719,7 @@ def blk_func(values: ArrayLike) -> ArrayLike:
             mask = isna(values)
             if values.ndim == 1:
                 indexer = np.empty(values.shape, dtype=np.intp)
-                col_func(out=indexer, mask=mask)
+                col_func(out=indexer, mask=mask)  # type: ignore[arg-type]
                 return algorithms.take_nd(values, indexer)
 
             else:
@@ -4081,7 +4081,9 @@ def _nth(
     def quantile(
         self,
         q: float | AnyArrayLike = 0.5,
-        interpolation: str = "linear",
+        interpolation: Literal[
+            "linear", "lower", "higher", "nearest", "midpoint"
+        ] = "linear",
         numeric_only: bool = False,
     ):
         """
@@ -4270,7 +4272,7 @@ def blk_func(values: ArrayLike) -> ArrayLike:
                 func(
                     out[0],
                     values=vals,
-                    mask=mask,
+                    mask=mask,  # type: ignore[arg-type]
                     result_mask=result_mask,
                     is_datetimelike=is_datetimelike,
                 )
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index b32119a2ddbde..4c7fe604e452d 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -898,7 +898,7 @@ def _unob_index_and_ids(
         return unob_index, unob_ids
 
     @final
-    def get_group_levels(self) -> Generator[Index, None, None]:
+    def get_group_levels(self) -> Generator[Index]:
         # Note: only called from _insert_inaxis_grouper, which
         #  is only called for BaseGrouper, never for BinGrouper
         result_index = self.result_index
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 8feac890883eb..94717141b30b0 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -991,7 +991,7 @@ def length(self) -> Index:
     # --------------------------------------------------------------------
     # Set Operations
 
-    def _intersection(self, other, sort):
+    def _intersection(self, other, sort: bool = False):
         """
         intersection specialized to the case with matching dtypes.
         """
@@ -1006,7 +1006,7 @@ def _intersection(self, other, sort):
             # duplicates
             taken = self._intersection_non_unique(other)
 
-        if sort is None:
+        if sort:
             taken = taken.sort_values()
 
         return taken
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 9eccb7645fbe7..ae9b272af9fe9 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -2664,7 +2664,7 @@ def _reorder_ilevels(self, order) -> MultiIndex:
 
     def _recode_for_new_levels(
         self, new_levels, copy: bool = True
-    ) -> Generator[np.ndarray, None, None]:
+    ) -> Generator[np.ndarray]:
         if len(new_levels) > self.nlevels:
             raise AssertionError(
                 f"Length of new_levels ({len(new_levels)}) "
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index cb40e920149fa..a3ff577966a6d 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -388,7 +388,7 @@ def _split_op_result(self, result: ArrayLike) -> list[Block]:
         return [nb]
 
     @final
-    def _split(self) -> Generator[Block, None, None]:
+    def _split(self) -> Generator[Block]:
         """
         Split a block into a list of single-column blocks.
         """
diff --git a/pandas/core/internals/concat.py b/pandas/core/internals/concat.py
index b96d5a59effce..2ee7d3948a70f 100644
--- a/pandas/core/internals/concat.py
+++ b/pandas/core/internals/concat.py
@@ -250,7 +250,7 @@ def _concat_homogeneous_fastpath(
 
 def _get_combined_plan(
     mgrs: list[BlockManager],
-) -> Generator[tuple[BlockPlacement, list[JoinUnit]], None, None]:
+) -> Generator[tuple[BlockPlacement, list[JoinUnit]]]:
     max_len = mgrs[0].shape[0]
 
     blknos_list = [mgr.blknos for mgr in mgrs]
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index aa4a785519051..a3738bb25f56c 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -856,7 +856,7 @@ def _slice_take_blocks_ax0(
         *,
         use_na_proxy: bool = False,
         ref_inplace_op: bool = False,
-    ) -> Generator[Block, None, None]:
+    ) -> Generator[Block]:
         """
         Slice/take blocks along axis=0.
 
@@ -1731,7 +1731,7 @@ def unstack(self, unstacker, fill_value) -> BlockManager:
         bm = BlockManager(new_blocks, [new_columns, new_index], verify_integrity=False)
         return bm
 
-    def to_iter_dict(self) -> Generator[tuple[str, Self], None, None]:
+    def to_iter_dict(self) -> Generator[tuple[str, Self]]:
         """
         Yield a tuple of (str(dtype), BlockManager)
 
diff --git a/pandas/core/methods/to_dict.py b/pandas/core/methods/to_dict.py
index 84202a4fcc840..aea95e4684573 100644
--- a/pandas/core/methods/to_dict.py
+++ b/pandas/core/methods/to_dict.py
@@ -33,7 +33,7 @@
 
 def create_data_for_split(
     df: DataFrame, are_all_object_dtype_cols: bool, object_dtype_indices: list[int]
-) -> Generator[list, None, None]:
+) -> Generator[list]:
     """
     Simple helper method to create data for to ``to_dict(orient="split")``
     to create the main output data
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 711396096a5e3..42fed83398737 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -404,7 +404,7 @@ def transform(self, arg, *args, **kwargs):
             arg, *args, **kwargs
         )
 
-    def _downsample(self, f, **kwargs):
+    def _downsample(self, how, **kwargs):
         raise AbstractMethodError(self)
 
     def _upsample(self, f, limit: int | None = None, fill_value=None):
diff --git a/pandas/core/series.py b/pandas/core/series.py
index bbcb6615aeefd..fe2bb0b5aa5c3 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -813,8 +813,7 @@ def _values(self):
     def _references(self) -> BlockValuesRefs:
         return self._mgr._block.refs
 
-    # error: Decorated property not supported
-    @Appender(base.IndexOpsMixin.array.__doc__)  # type: ignore[misc]
+    @Appender(base.IndexOpsMixin.array.__doc__)  # type: ignore[prop-decorator]
     @property
     def array(self) -> ExtensionArray:
         return self._mgr.array_values()
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index 86c7316320f44..4680a63bf57a1 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -1000,7 +1000,7 @@ def to_datetime(
         dayfirst=dayfirst,
         yearfirst=yearfirst,
         errors=errors,
-        exact=exact,
+        exact=exact,  # type: ignore[arg-type]
     )
     result: Timestamp | NaTType | Series | Index
 
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index 9ea825ad4e44d..cf74cc30f3c5d 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -1507,7 +1507,7 @@ def _generate_cython_apply_func(
             window_aggregations.roll_apply,
             args=args,
             kwargs=kwargs,
-            raw=raw,
+            raw=bool(raw),
             function=function,
         )
 
diff --git a/pandas/io/excel/_odswriter.py b/pandas/io/excel/_odswriter.py
index 0ddb59d3413ff..10a06aec72a57 100644
--- a/pandas/io/excel/_odswriter.py
+++ b/pandas/io/excel/_odswriter.py
@@ -34,7 +34,7 @@ class ODSWriter(ExcelWriter):
     _engine = "odf"
     _supported_extensions = (".ods",)
 
-    def __init__(
+    def __init__(  # pyright: ignore[reportInconsistentConstructor]
         self,
         path: FilePath | WriteExcelBuffer | ExcelWriter,
         engine: str | None = None,
diff --git a/pandas/io/excel/_openpyxl.py b/pandas/io/excel/_openpyxl.py
index 218a592c22b4a..3055c68a93cbc 100644
--- a/pandas/io/excel/_openpyxl.py
+++ b/pandas/io/excel/_openpyxl.py
@@ -42,7 +42,7 @@ class OpenpyxlWriter(ExcelWriter):
     _engine = "openpyxl"
     _supported_extensions = (".xlsx", ".xlsm")
 
-    def __init__(
+    def __init__(  # pyright: ignore[reportInconsistentConstructor]
         self,
         path: FilePath | WriteExcelBuffer | ExcelWriter,
         engine: str | None = None,
diff --git a/pandas/io/excel/_xlsxwriter.py b/pandas/io/excel/_xlsxwriter.py
index b2fd24a670300..4a7b8eee2bfce 100644
--- a/pandas/io/excel/_xlsxwriter.py
+++ b/pandas/io/excel/_xlsxwriter.py
@@ -181,7 +181,7 @@ class XlsxWriter(ExcelWriter):
     _engine = "xlsxwriter"
     _supported_extensions = (".xlsx",)
 
-    def __init__(
+    def __init__(  # pyright: ignore[reportInconsistentConstructor]
         self,
         path: FilePath | WriteExcelBuffer | ExcelWriter,
         engine: str | None = None,
diff --git a/pandas/io/formats/css.py b/pandas/io/formats/css.py
index 0af04526ea96d..10c970887e03b 100644
--- a/pandas/io/formats/css.py
+++ b/pandas/io/formats/css.py
@@ -34,9 +34,7 @@ def _side_expander(prop_fmt: str) -> Callable:
         function: Return to call when a 'border(-{side}): {value}' string is encountered
     """
 
-    def expand(
-        self: CSSResolver, prop: str, value: str
-    ) -> Generator[tuple[str, str], None, None]:
+    def expand(self: CSSResolver, prop: str, value: str) -> Generator[tuple[str, str]]:
         """
         Expand shorthand property into side-specific property (top, right, bottom, left)
 
@@ -81,9 +79,7 @@ def _border_expander(side: str = "") -> Callable:
     if side != "":
         side = f"-{side}"
 
-    def expand(
-        self: CSSResolver, prop: str, value: str
-    ) -> Generator[tuple[str, str], None, None]:
+    def expand(self: CSSResolver, prop: str, value: str) -> Generator[tuple[str, str]]:
         """
         Expand border into color, style, and width tuples
 
@@ -392,7 +388,7 @@ def _error() -> str:
             size_fmt = f"{val:f}pt"
         return size_fmt
 
-    def atomize(self, declarations: Iterable) -> Generator[tuple[str, str], None, None]:
+    def atomize(self, declarations: Iterable) -> Generator[tuple[str, str]]:
         for prop, value in declarations:
             prop = prop.lower()
             value = value.lower()
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index 9ad5ac83e9eae..5aecc6af712e5 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -1024,7 +1024,7 @@ def save_to_buffer(
 @contextmanager
 def _get_buffer(
     buf: FilePath | WriteBuffer[str] | None, encoding: str | None = None
-) -> Generator[WriteBuffer[str], None, None] | Generator[StringIO, None, None]:
+) -> Generator[WriteBuffer[str]] | Generator[StringIO]:
     """
     Context manager to open, yield and close buffer for filenames or Path-like
     objects, otherwise yield buf unchanged.
diff --git a/pandas/io/parsers/python_parser.py b/pandas/io/parsers/python_parser.py
index 3a2a1c37f1879..99d584db61755 100644
--- a/pandas/io/parsers/python_parser.py
+++ b/pandas/io/parsers/python_parser.py
@@ -1203,7 +1203,7 @@ def _rows_to_cols(self, content: list[list[Scalar]]) -> list[np.ndarray]:
                     if callable(self.on_bad_lines):
                         new_l = self.on_bad_lines(_content)
                         if new_l is not None:
-                            content.append(new_l)
+                            content.append(new_l)  # pyright: ignore[reportArgumentType]
                     elif self.on_bad_lines in (
                         self.BadLineHandleMethod.ERROR,
                         self.BadLineHandleMethod.WARN,
diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 25257d5fcc192..c5aab4d967cd4 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -516,7 +516,7 @@ def _process_columntext_subheader(self, offset: int, length: int) -> None:
                 buf = self._read_bytes(offset1, self._lcs)
                 self.creator_proc = buf[0 : self._lcp]
             if hasattr(self, "creator_proc"):
-                self.creator_proc = self._convert_header_text(self.creator_proc)
+                self.creator_proc = self._convert_header_text(self.creator_proc)  # pyright: ignore[reportArgumentType]
 
     def _process_columnname_subheader(self, offset: int, length: int) -> None:
         int_len = self._int_length
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index 99dd06568fa01..9aff5600cf49b 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -233,7 +233,7 @@ def _wrap_result_adbc(
 
 
 @overload
-def read_sql_table(
+def read_sql_table(  # pyright: ignore[reportOverlappingOverload]
     table_name: str,
     con,
     schema=...,
@@ -364,7 +364,7 @@ def read_sql_table(
 
 
 @overload
-def read_sql_query(
+def read_sql_query(  # pyright: ignore[reportOverlappingOverload]
     sql,
     con,
     index_col: str | list[str] | None = ...,
@@ -500,7 +500,7 @@ def read_sql_query(
 
 
 @overload
-def read_sql(
+def read_sql(  # pyright: ignore[reportOverlappingOverload]
     sql,
     con,
     index_col: str | list[str] | None = ...,
@@ -1119,7 +1119,7 @@ def _query_iterator(
         coerce_float: bool = True,
         parse_dates=None,
         dtype_backend: DtypeBackend | Literal["numpy"] = "numpy",
-    ) -> Generator[DataFrame, None, None]:
+    ) -> Generator[DataFrame]:
         """Return generator through chunked result set."""
         has_read_data = False
         with exit_stack:
@@ -1732,7 +1732,7 @@ def _query_iterator(
         parse_dates=None,
         dtype: DtypeArg | None = None,
         dtype_backend: DtypeBackend | Literal["numpy"] = "numpy",
-    ) -> Generator[DataFrame, None, None]:
+    ) -> Generator[DataFrame]:
         """Return generator through chunked result set"""
         has_read_data = False
         with exit_stack:
@@ -2682,7 +2682,7 @@ def _query_iterator(
         parse_dates=None,
         dtype: DtypeArg | None = None,
         dtype_backend: DtypeBackend | Literal["numpy"] = "numpy",
-    ) -> Generator[DataFrame, None, None]:
+    ) -> Generator[DataFrame]:
         """Return generator through chunked result set"""
         has_read_data = False
         while True:
diff --git a/pandas/plotting/_matplotlib/converter.py b/pandas/plotting/_matplotlib/converter.py
index fc63d65f1e160..4c00049075d03 100644
--- a/pandas/plotting/_matplotlib/converter.py
+++ b/pandas/plotting/_matplotlib/converter.py
@@ -92,7 +92,7 @@ def wrapper(*args, **kwargs):
 
 
 @contextlib.contextmanager
-def pandas_converters() -> Generator[None, None, None]:
+def pandas_converters() -> Generator[None]:
     """
     Context manager registering pandas' converters for a plot.
 
@@ -527,7 +527,7 @@ def _get_periods_per_ymd(freq: BaseOffset) -> tuple[int, int, int]:
 
     ppd = -1  # placeholder for above-day freqs
 
-    if dtype_code >= FreqGroup.FR_HR.value:
+    if dtype_code >= FreqGroup.FR_HR.value:  # pyright: ignore[reportAttributeAccessIssue]
         # error: "BaseOffset" has no attribute "_creso"
         ppd = periods_per_day(freq._creso)  # type: ignore[attr-defined]
         ppm = 28 * ppd
@@ -684,7 +684,7 @@ def _second_finder(label_interval: int) -> None:
     elif span <= periodsperyear // 4:
         month_start = _period_break(dates_, "month")
         info_maj[month_start] = True
-        if dtype_code < FreqGroup.FR_HR.value:
+        if dtype_code < FreqGroup.FR_HR.value:  # pyright: ignore[reportAttributeAccessIssue]
             info["min"] = True
         else:
             day_start = _period_break(dates_, "day")
@@ -910,7 +910,7 @@ def get_finder(freq: BaseOffset):
         return _quarterly_finder
     elif fgroup == FreqGroup.FR_MTH:
         return _monthly_finder
-    elif (dtype_code >= FreqGroup.FR_BUS.value) or fgroup == FreqGroup.FR_WK:
+    elif (dtype_code >= FreqGroup.FR_BUS.value) or fgroup == FreqGroup.FR_WK:  # pyright: ignore[reportAttributeAccessIssue]
         return _daily_finder
     else:  # pragma: no cover
         raise NotImplementedError(f"Unsupported frequency: {dtype_code}")
diff --git a/pandas/plotting/_matplotlib/tools.py b/pandas/plotting/_matplotlib/tools.py
index f9c370b2486fd..d5624aecd1215 100644
--- a/pandas/plotting/_matplotlib/tools.py
+++ b/pandas/plotting/_matplotlib/tools.py
@@ -442,7 +442,7 @@ def handle_shared_axes(
                     _remove_labels_from_axis(ax.yaxis)
 
 
-def flatten_axes(axes: Axes | Iterable[Axes]) -> Generator[Axes, None, None]:
+def flatten_axes(axes: Axes | Iterable[Axes]) -> Generator[Axes]:
     if not is_list_like(axes):
         yield axes  # type: ignore[misc]
     elif isinstance(axes, (np.ndarray, ABCIndex)):
diff --git a/pandas/plotting/_misc.py b/pandas/plotting/_misc.py
index 81940613dd2b0..7face74dcbc89 100644
--- a/pandas/plotting/_misc.py
+++ b/pandas/plotting/_misc.py
@@ -715,7 +715,7 @@ def _get_canonical_key(self, key: str) -> str:
         return self._ALIASES.get(key, key)
 
     @contextmanager
-    def use(self, key, value) -> Generator[_Options, None, None]:
+    def use(self, key, value) -> Generator[_Options]:
         """
         Temporarily set a parameter value using the with statement.
         Aliasing allowed.
diff --git a/pandas/tests/frame/test_ufunc.py b/pandas/tests/frame/test_ufunc.py
index 95b315c32dca5..092e65dd4b431 100644
--- a/pandas/tests/frame/test_ufunc.py
+++ b/pandas/tests/frame/test_ufunc.py
@@ -66,14 +66,14 @@ def test_binary_input_dispatch_binop(dtype):
     [
         (np.add, 1, [2, 3, 4, 5]),
         (
-            partial(np.add, where=[[False, True], [True, False]]),
+            partial(np.add, where=[[False, True], [True, False]]),  # type: ignore[misc]
             np.array([[1, 1], [1, 1]]),
             [0, 3, 4, 0],
         ),
         (np.power, np.array([[1, 1], [2, 2]]), [1, 2, 9, 16]),
         (np.subtract, 2, [-1, 0, 1, 2]),
         (
-            partial(np.negative, where=np.array([[False, True], [True, False]])),
+            partial(np.negative, where=np.array([[False, True], [True, False]])),  # type: ignore[misc]
             None,
             [0, -2, -3, 0],
         ),
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 2b62b384930d6..19b46d9b2c15f 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -1635,7 +1635,7 @@ def test_generated_op_names(opname, index):
         partial(DatetimeIndex, data=["2020-01-01"]),
         partial(PeriodIndex, data=["2020-01-01"]),
         partial(TimedeltaIndex, data=["1 day"]),
-        partial(RangeIndex, data=range(1)),
+        partial(RangeIndex, start=range(1)),
         partial(IntervalIndex, data=[pd.Interval(0, 1)]),
         partial(Index, data=["a"], dtype=object),
         partial(MultiIndex, levels=[1], codes=[0]),
diff --git a/pandas/util/_exceptions.py b/pandas/util/_exceptions.py
index 5f50838d37315..b3c8e54d3ca7f 100644
--- a/pandas/util/_exceptions.py
+++ b/pandas/util/_exceptions.py
@@ -4,7 +4,10 @@
 import inspect
 import os
 import re
-from typing import TYPE_CHECKING
+from typing import (
+    TYPE_CHECKING,
+    Any,
+)
 import warnings
 
 if TYPE_CHECKING:
@@ -13,7 +16,7 @@
 
 
 @contextlib.contextmanager
-def rewrite_exception(old_name: str, new_name: str) -> Generator[None, None, None]:
+def rewrite_exception(old_name: str, new_name: str) -> Generator[None]:
     """
     Rewrite the message of an exception.
     """
@@ -24,7 +27,7 @@ def rewrite_exception(old_name: str, new_name: str) -> Generator[None, None, Non
             raise
         msg = str(err.args[0])
         msg = msg.replace(old_name, new_name)
-        args: tuple[str, ...] = (msg,)
+        args: tuple[Any, ...] = (msg,)
         if len(err.args) > 1:
             args = args + err.args[1:]
         err.args = args
@@ -66,7 +69,7 @@ def rewrite_warning(
     target_category: type[Warning],
     new_message: str,
     new_category: type[Warning] | None = None,
-) -> Generator[None, None, None]:
+) -> Generator[None]:
     """
     Rewrite the message of a warning.
 
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 52d2553fc4001..1bf42af6bf2cd 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -53,10 +53,10 @@ seaborn
 moto
 flask
 asv>=0.6.1
-flake8==6.1.0
-mypy==1.9.0
+flake8==7.1.0
+mypy==1.11.2
 tokenize-rt
-pre-commit>=3.6.0
+pre-commit>=4.0.1
 gitpython
 gitdb
 google-auth

From f1bdd0fa571e8689274c8dc7ba62ae503d74a568 Mon Sep 17 00:00:00 2001
From: Sparsh Sah <sparshsah@gmail.com>
Date: Fri, 11 Oct 2024 10:19:44 -0700
Subject: [PATCH 18/20] DOC: Fix `GroupBy.ffill()` doc reference to rows
 (#60019)

Fix `groupby.ffill()` doc reference to rows
---
 pandas/core/groupby/groupby.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 5bf3e0e4de2fb..8dfef9e70db52 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -3833,7 +3833,7 @@ def ffill(self, limit: int | None = None):
         3  1.0  3.0  NaN  NaN
         4  1.0  1.0  NaN  NaN
 
-        Only replace the first NaN element within a group along rows.
+        Only replace the first NaN element within a group along columns.
 
         >>> df.groupby("key").ffill(limit=1)
              A    B    C

From 2a10e04a099d5f1633abcdfbb2dd9fdf09142f8d Mon Sep 17 00:00:00 2001
From: Wong2333 <3201884732@qq.com>
Date: Sat, 12 Oct 2024 11:14:27 +0800
Subject: [PATCH 19/20] DOC: Fix title capitalization in documentation files
 (#32550) (#60021)

* DOC: Fix title capitalization in documentation file

* DOC: Fix title capitalization in documentation files
---
 doc/source/whatsnew/v0.12.0.rst | 12 ++++++------
 doc/source/whatsnew/v3.0.0.rst  |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/doc/source/whatsnew/v0.12.0.rst b/doc/source/whatsnew/v0.12.0.rst
index c805758f85b35..08d3a6b188322 100644
--- a/doc/source/whatsnew/v0.12.0.rst
+++ b/doc/source/whatsnew/v0.12.0.rst
@@ -133,9 +133,9 @@ API changes
     to be inserted if ``True``, default is ``False`` (same as prior to 0.12) (:issue:`3679`)
   - Implement ``__nonzero__`` for ``NDFrame`` objects (:issue:`3691`, :issue:`3696`)
 
-  - IO api
+  - IO API
 
-    - added top-level function ``read_excel`` to replace the following,
+    - Added top-level function ``read_excel`` to replace the following,
       The original API is deprecated and will be removed in a future version
 
       .. code-block:: python
@@ -153,7 +153,7 @@ API changes
 
          pd.read_excel("path_to_file.xls", "Sheet1", index_col=None, na_values=["NA"])
 
-    - added top-level function ``read_sql`` that is equivalent to the following
+    - Added top-level function ``read_sql`` that is equivalent to the following
 
       .. code-block:: python
 
@@ -482,11 +482,11 @@ Bug fixes
 
   - ``HDFStore``
 
-    - will retain index attributes (freq,tz,name) on recreation (:issue:`3499`)
-    - will warn with a ``AttributeConflictWarning`` if you are attempting to append
+    - Will retain index attributes (freq,tz,name) on recreation (:issue:`3499`)
+    - Will warn with a ``AttributeConflictWarning`` if you are attempting to append
       an index with a different frequency than the existing, or attempting
       to append an index with a different name than the existing
-    - support datelike columns with a timezone as data_columns (:issue:`2852`)
+    - Support datelike columns with a timezone as data_columns (:issue:`2852`)
 
   - Non-unique index support clarified (:issue:`3468`).
 
diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 321005272817d..e5376177d3381 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -16,12 +16,12 @@ Enhancements
 
 .. _whatsnew_300.enhancements.enhancement1:
 
-enhancement1
+Enhancement1
 ^^^^^^^^^^^^
 
 .. _whatsnew_300.enhancements.enhancement2:
 
-enhancement2
+Enhancement2
 ^^^^^^^^^^^^
 
 .. _whatsnew_300.enhancements.other:

From 68d9dcab5b543adb3bfe5b83563c61a9b8afae77 Mon Sep 17 00:00:00 2001
From: Tuhin Sharma <tuhinsharma121@gmail.com>
Date: Tue, 22 Oct 2024 01:43:47 +0530
Subject: [PATCH 20/20] DOC: fix SA01 for pandas.core.resample.Resampler.ohlc
 (#60036)

---
 ci/code_checks.sh              | 3 ---
 pandas/core/groupby/groupby.py | 6 ++++++
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 1974c98a1d1ff..427938c3c5fba 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -104,7 +104,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.core.groupby.DataFrameGroupBy.indices SA01" \
         -i "pandas.core.groupby.DataFrameGroupBy.nth PR02" \
         -i "pandas.core.groupby.DataFrameGroupBy.nunique SA01" \
-        -i "pandas.core.groupby.DataFrameGroupBy.ohlc SA01" \
         -i "pandas.core.groupby.DataFrameGroupBy.plot PR02" \
         -i "pandas.core.groupby.DataFrameGroupBy.sem SA01" \
         -i "pandas.core.groupby.SeriesGroupBy.__iter__ RT03,SA01" \
@@ -114,7 +113,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.core.groupby.SeriesGroupBy.is_monotonic_decreasing SA01" \
         -i "pandas.core.groupby.SeriesGroupBy.is_monotonic_increasing SA01" \
         -i "pandas.core.groupby.SeriesGroupBy.nth PR02" \
-        -i "pandas.core.groupby.SeriesGroupBy.ohlc SA01" \
         -i "pandas.core.groupby.SeriesGroupBy.plot PR02" \
         -i "pandas.core.groupby.SeriesGroupBy.sem SA01" \
         -i "pandas.core.resample.Resampler.__iter__ RT03,SA01" \
@@ -124,7 +122,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         -i "pandas.core.resample.Resampler.max PR01,RT03,SA01" \
         -i "pandas.core.resample.Resampler.mean SA01" \
         -i "pandas.core.resample.Resampler.min PR01,RT03,SA01" \
-        -i "pandas.core.resample.Resampler.ohlc SA01" \
         -i "pandas.core.resample.Resampler.prod SA01" \
         -i "pandas.core.resample.Resampler.quantile PR01,PR07" \
         -i "pandas.core.resample.Resampler.sem SA01" \
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 8dfef9e70db52..f12ded6045e80 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -3224,6 +3224,12 @@ def ohlc(self) -> DataFrame:
         DataFrame
             Open, high, low and close values within each group.
 
+        See Also
+        --------
+        DataFrame.agg : Aggregate using one or more operations over the specified axis.
+        DataFrame.resample : Resample time-series data.
+        DataFrame.groupby : Group DataFrame using a mapper or by a Series of columns.
+
         Examples
         --------