diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 7829f3207..e08722d4d 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -14,14 +14,7 @@ repos:
     rev: v0.13.3
     hooks:
     -   id: ruff-check
-        args: [
-          --exit-non-zero-on-fix,
-          --target-version, py39,
-          --extend-select, "PYI,UP,RUF100",
-          --ignore, "E501,E731,F841,PYI042",
-          --per-file-ignores, "_*.pyi:PYI001",
-          --fix
-        ]
+        args: [--exit-non-zero-on-fix]
 -   repo: https://github.com/codespell-project/codespell
     rev: v2.4.1
     hooks:
diff --git a/pandas-stubs/_libs/lib.pyi b/pandas-stubs/_libs/lib.pyi
index b7c735953..c3936d467 100644
--- a/pandas-stubs/_libs/lib.pyi
+++ b/pandas-stubs/_libs/lib.pyi
@@ -2,14 +2,12 @@ from enum import Enum
 from typing import (
     Final,
     Literal,
-)
-
-import numpy as np
-from typing_extensions import (
     TypeAlias,
     TypeGuard,
 )
 
+import numpy as np
+
 class _NoDefault(Enum):
     no_default = ...
 
diff --git a/pandas-stubs/_libs/missing.pyi b/pandas-stubs/_libs/missing.pyi
index c06bf3616..f0bf682e3 100644
--- a/pandas-stubs/_libs/missing.pyi
+++ b/pandas-stubs/_libs/missing.pyi
@@ -1,6 +1,6 @@
+from collections.abc import Callable
 from typing import (
     Any,
-    Callable,
     Literal,
     overload,
 )
diff --git a/pandas-stubs/_libs/tslibs/nattype.pyi b/pandas-stubs/_libs/tslibs/nattype.pyi
index 211066a22..c4aa0a14c 100644
--- a/pandas-stubs/_libs/tslibs/nattype.pyi
+++ b/pandas-stubs/_libs/tslibs/nattype.pyi
@@ -4,14 +4,14 @@ from datetime import (
     timedelta,
     tzinfo as _tzinfo,
 )
-from typing import Literal
-
-import numpy as np
-from typing_extensions import (
-    Self,
+from typing import (
+    Literal,
     TypeAlias,
 )
 
+import numpy as np
+from typing_extensions import Self
+
 from pandas._libs.tslibs.period import Period
 from pandas._typing import (
     Frequency,
diff --git a/pandas-stubs/_libs/tslibs/period.pyi b/pandas-stubs/_libs/tslibs/period.pyi
index 897153c2e..9a7a23f4d 100644
--- a/pandas-stubs/_libs/tslibs/period.pyi
+++ b/pandas-stubs/_libs/tslibs/period.pyi
@@ -1,6 +1,7 @@
 import datetime
 from typing import (
     Literal,
+    TypeAlias,
     overload,
 )
 
@@ -12,7 +13,6 @@ from pandas import (
     Timedelta,
     TimedeltaIndex,
 )
-from typing_extensions import TypeAlias
 
 from pandas._libs.tslibs import NaTType
 from pandas._libs.tslibs.offsets import BaseOffset
diff --git a/pandas-stubs/_libs/tslibs/timedeltas.pyi b/pandas-stubs/_libs/tslibs/timedeltas.pyi
index 9ad5e0e68..71cf65005 100644
--- a/pandas-stubs/_libs/tslibs/timedeltas.pyi
+++ b/pandas-stubs/_libs/tslibs/timedeltas.pyi
@@ -5,6 +5,7 @@ from typing import (
     ClassVar,
     Literal,
     NamedTuple,
+    TypeAlias,
     overload,
 )
 
@@ -17,10 +18,7 @@ from pandas import (
     Series,
     TimedeltaIndex,
 )
-from typing_extensions import (
-    Self,
-    TypeAlias,
-)
+from typing_extensions import Self
 
 from pandas._libs.tslibs import (
     BaseOffset,
diff --git a/pandas-stubs/_libs/tslibs/timestamps.pyi b/pandas-stubs/_libs/tslibs/timestamps.pyi
index fd34007d4..0998b2dca 100644
--- a/pandas-stubs/_libs/tslibs/timestamps.pyi
+++ b/pandas-stubs/_libs/tslibs/timestamps.pyi
@@ -13,6 +13,7 @@ from typing import (
     ClassVar,
     Literal,
     SupportsIndex,
+    TypeAlias,
     overload,
 )
 
@@ -26,7 +27,6 @@ from pandas.core.series import Series
 from typing_extensions import (
     Never,
     Self,
-    TypeAlias,
 )
 
 from pandas._libs.tslibs import (
diff --git a/pandas-stubs/_typing.pyi b/pandas-stubs/_typing.pyi
index b852fcc65..d84b91342 100644
--- a/pandas-stubs/_typing.pyi
+++ b/pandas-stubs/_typing.pyi
@@ -19,6 +19,7 @@ from typing import (
     Literal,
     Protocol,
     SupportsIndex,
+    TypeAlias,
     TypedDict,
     Union,
     overload,
@@ -36,7 +37,6 @@ from pandas.core.series import Series
 from pandas.core.tools.datetimes import FulldatetimeDict
 from typing_extensions import (
     ParamSpec,
-    TypeAlias,
     TypeVar,
     override,
 )
diff --git a/pandas-stubs/core/accessor.pyi b/pandas-stubs/core/accessor.pyi
index 0b95bb1b8..50a97fdc1 100644
--- a/pandas-stubs/core/accessor.pyi
+++ b/pandas-stubs/core/accessor.pyi
@@ -1,4 +1,4 @@
-from typing import Callable
+from collections.abc import Callable
 
 from pandas._typing import TypeT
 
diff --git a/pandas-stubs/core/arrays/datetimelike.pyi b/pandas-stubs/core/arrays/datetimelike.pyi
index 0bec76219..ec404037e 100644
--- a/pandas-stubs/core/arrays/datetimelike.pyi
+++ b/pandas-stubs/core/arrays/datetimelike.pyi
@@ -1,15 +1,15 @@
 from collections.abc import Sequence
-from typing import overload
+from typing import (
+    TypeAlias,
+    overload,
+)
 
 import numpy as np
 from pandas.core.arrays.base import (
     ExtensionArray,
     ExtensionOpsMixin,
 )
-from typing_extensions import (
-    Self,
-    TypeAlias,
-)
+from typing_extensions import Self
 
 from pandas._libs import (
     NaT as NaT,
diff --git a/pandas-stubs/core/arrays/interval.pyi b/pandas-stubs/core/arrays/interval.pyi
index a7c8d5a6e..a40e229f0 100644
--- a/pandas-stubs/core/arrays/interval.pyi
+++ b/pandas-stubs/core/arrays/interval.pyi
@@ -1,4 +1,7 @@
-from typing import overload
+from typing import (
+    TypeAlias,
+    overload,
+)
 
 import numpy as np
 from pandas import (
@@ -6,10 +9,7 @@ from pandas import (
     Series,
 )
 from pandas.core.arrays.base import ExtensionArray as ExtensionArray
-from typing_extensions import (
-    Self,
-    TypeAlias,
-)
+from typing_extensions import Self
 
 from pandas._libs.interval import (
     Interval as Interval,
diff --git a/pandas-stubs/core/dtypes/common.pyi b/pandas-stubs/core/dtypes/common.pyi
index 5707260df..e8f5c2165 100644
--- a/pandas-stubs/core/dtypes/common.pyi
+++ b/pandas-stubs/core/dtypes/common.pyi
@@ -1,6 +1,7 @@
+from typing import TypeAlias
+
 import pandas as pd
 from pandas.api.extensions import ExtensionDtype
-from typing_extensions import TypeAlias
 
 from pandas._typing import (
     ArrayLike,
diff --git a/pandas-stubs/core/dtypes/generic.pyi b/pandas-stubs/core/dtypes/generic.pyi
index 7ef048ddd..95b60cd22 100644
--- a/pandas-stubs/core/dtypes/generic.pyi
+++ b/pandas-stubs/core/dtypes/generic.pyi
@@ -1,6 +1,7 @@
+from typing import TypeAlias
+
 from pandas import Series
 from pandas.core.arrays import ExtensionArray
-from typing_extensions import TypeAlias
 
 ABCSeries: TypeAlias = type[Series]
 ABCExtensionArray: TypeAlias = type[ExtensionArray]
diff --git a/pandas-stubs/core/frame.pyi b/pandas-stubs/core/frame.pyi
index ce61a30f1..347cab728 100644
--- a/pandas-stubs/core/frame.pyi
+++ b/pandas-stubs/core/frame.pyi
@@ -23,6 +23,7 @@ from typing import (
     Generic,
     Literal,
     NoReturn,
+    TypeAlias,
     TypeVar,
     final,
     overload,
@@ -73,7 +74,6 @@ from pandas.core.window.rolling import (
 from typing_extensions import (
     Never,
     Self,
-    TypeAlias,
 )
 import xarray as xr
 
diff --git a/pandas-stubs/core/generic.pyi b/pandas-stubs/core/generic.pyi
index fb7f17928..5ce8ac40d 100644
--- a/pandas-stubs/core/generic.pyi
+++ b/pandas-stubs/core/generic.pyi
@@ -14,6 +14,7 @@ import sqlite3
 from typing import (
     Any,
     ClassVar,
+    Concatenate,
     Literal,
     final,
     overload,
@@ -28,7 +29,7 @@ from pandas.core.series import (
 )
 import sqlalchemy.engine
 from typing_extensions import (
-    Concatenate,
+    Never,
     Self,
 )
 
@@ -315,6 +316,42 @@ class NDFrame(indexing.IndexingMixin):
     @final
     def __delitem__(self, idx: Hashable) -> None: ...
     @overload
+    def drop(
+        self,
+        labels=...,
+        *,
+        axis=...,
+        index: None,
+        columns=...,
+        level=...,
+        inplace=...,
+        errors=...,
+    ) -> Never: ...
+    @overload
+    def drop(
+        self,
+        labels=...,
+        *,
+        axis=...,
+        index=...,
+        columns: None,
+        level=...,
+        inplace=...,
+        errors=...,
+    ) -> Never: ...
+    @overload
+    def drop(
+        self,
+        labels: None,
+        *,
+        axis=...,
+        index=...,
+        columns=...,
+        level=...,
+        inplace=...,
+        errors=...,
+    ) -> Never: ...
+    @overload
     def drop(
         self,
         labels: None = ...,
diff --git a/pandas-stubs/core/groupby/generic.pyi b/pandas-stubs/core/groupby/generic.pyi
index a9be50903..2a07f47b8 100644
--- a/pandas-stubs/core/groupby/generic.pyi
+++ b/pandas-stubs/core/groupby/generic.pyi
@@ -12,6 +12,7 @@ from typing import (
     Literal,
     NamedTuple,
     Protocol,
+    TypeAlias,
     TypeVar,
     final,
     overload,
@@ -26,10 +27,7 @@ from pandas.core.groupby.groupby import (
     GroupByPlot,
 )
 from pandas.core.series import Series
-from typing_extensions import (
-    Self,
-    TypeAlias,
-)
+from typing_extensions import Self
 
 from pandas._libs.tslibs.timestamps import Timestamp
 from pandas._typing import (
diff --git a/pandas-stubs/core/groupby/groupby.pyi b/pandas-stubs/core/groupby/groupby.pyi
index 174d16ef9..4e26e0ecd 100644
--- a/pandas-stubs/core/groupby/groupby.pyi
+++ b/pandas-stubs/core/groupby/groupby.pyi
@@ -8,8 +8,10 @@ from collections.abc import (
 import datetime as dt
 from typing import (
     Any,
+    Concatenate,
     Generic,
     Literal,
+    TypeAlias,
     TypeVar,
     final,
     overload,
@@ -38,11 +40,7 @@ from pandas.core.window import (
     ExponentialMovingWindowGroupby,
     RollingGroupby,
 )
-from typing_extensions import (
-    Concatenate,
-    Self,
-    TypeAlias,
-)
+from typing_extensions import Self
 
 from pandas._libs.lib import _NoDefaultDoNotUse
 from pandas._libs.tslibs import BaseOffset
diff --git a/pandas-stubs/core/indexes/interval.pyi b/pandas-stubs/core/indexes/interval.pyi
index 2ef586772..43c3595cd 100644
--- a/pandas-stubs/core/indexes/interval.pyi
+++ b/pandas-stubs/core/indexes/interval.pyi
@@ -5,6 +5,7 @@ from collections.abc import (
 import datetime as dt
 from typing import (
     Literal,
+    TypeAlias,
     final,
     overload,
 )
@@ -13,7 +14,6 @@ import numpy as np
 import pandas as pd
 from pandas import Index
 from pandas.core.indexes.extension import ExtensionIndex
-from typing_extensions import TypeAlias
 
 from pandas._libs.interval import (
     Interval as Interval,
diff --git a/pandas-stubs/core/indexing.pyi b/pandas-stubs/core/indexing.pyi
index 2e3f0237f..832e2618a 100644
--- a/pandas-stubs/core/indexing.pyi
+++ b/pandas-stubs/core/indexing.pyi
@@ -1,7 +1,9 @@
-from typing import TypeVar
+from typing import (
+    TypeAlias,
+    TypeVar,
+)
 
 from pandas.core.indexes.api import Index
-from typing_extensions import TypeAlias
 
 from pandas._libs.indexing import _NDFrameIndexerBase
 from pandas._typing import (
diff --git a/pandas-stubs/core/resample.pyi b/pandas-stubs/core/resample.pyi
index ac315c489..26ff08341 100644
--- a/pandas-stubs/core/resample.pyi
+++ b/pandas-stubs/core/resample.pyi
@@ -5,6 +5,7 @@ from collections.abc import (
 )
 from typing import (
     Literal,
+    TypeAlias,
     final,
     overload,
 )
@@ -18,10 +19,7 @@ from pandas import (
 from pandas.core.groupby.generic import SeriesGroupBy
 from pandas.core.groupby.groupby import BaseGroupBy
 from pandas.core.groupby.grouper import Grouper
-from typing_extensions import (
-    Self,
-    TypeAlias,
-)
+from typing_extensions import Self
 
 from pandas._typing import (
     S1,
diff --git a/pandas-stubs/core/reshape/concat.pyi b/pandas-stubs/core/reshape/concat.pyi
index 480668861..392cdf223 100644
--- a/pandas-stubs/core/reshape/concat.pyi
+++ b/pandas-stubs/core/reshape/concat.pyi
@@ -160,7 +160,7 @@ def concat(
 #     verify_integrity: bool = ...,
 #     sort: bool = ...,
 #     copy: bool = ...,
-# ) -> Union[DataFrame, Series]: ...
+# ) -> DataFrame | Series: ...
 
 # @overload
 # def concat(
@@ -176,4 +176,4 @@ def concat(
 #     verify_integrity: bool = ...,
 #     sort: bool = ...,
 #     copy: bool = ...,
-# ) -> Union[DataFrame, Series]: ...
+# ) -> DataFrame | Series: ...
diff --git a/pandas-stubs/core/reshape/pivot.pyi b/pandas-stubs/core/reshape/pivot.pyi
index 5554ce6fb..2c2157b3d 100644
--- a/pandas-stubs/core/reshape/pivot.pyi
+++ b/pandas-stubs/core/reshape/pivot.pyi
@@ -7,6 +7,7 @@ from collections.abc import (
 import datetime
 from typing import (
     Literal,
+    TypeAlias,
     overload,
 )
 
@@ -16,7 +17,6 @@ from pandas.core.frame import DataFrame
 from pandas.core.groupby.grouper import Grouper
 from pandas.core.indexes.base import Index
 from pandas.core.series import Series
-from typing_extensions import TypeAlias
 
 from pandas._typing import (
     AnyArrayLike,
diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
index 123b3f286..7140595db 100644
--- a/pandas-stubs/core/series.pyi
+++ b/pandas-stubs/core/series.pyi
@@ -27,6 +27,7 @@ from typing import (
     Literal,
     NoReturn,
     Protocol,
+    TypeAlias,
     TypeVar,
     final,
     overload,
@@ -96,7 +97,6 @@ from pandas.core.window.rolling import (
 from typing_extensions import (
     Never,
     Self,
-    TypeAlias,
 )
 import xarray as xr
 
diff --git a/pandas-stubs/core/tools/datetimes.pyi b/pandas-stubs/core/tools/datetimes.pyi
index 71c66299f..a4c841012 100644
--- a/pandas-stubs/core/tools/datetimes.pyi
+++ b/pandas-stubs/core/tools/datetimes.pyi
@@ -5,6 +5,7 @@ from datetime import (
 )
 from typing import (
     Literal,
+    TypeAlias,
     TypedDict,
     overload,
 )
@@ -17,7 +18,6 @@ from pandas import (
 from pandas.core.arrays import ExtensionArray
 from pandas.core.indexes.datetimes import DatetimeIndex
 from pandas.core.series import Series
-from typing_extensions import TypeAlias
 
 from pandas._libs.tslibs import NaTType
 from pandas._typing import (
diff --git a/pandas-stubs/core/tools/numeric.pyi b/pandas-stubs/core/tools/numeric.pyi
index e6eea93bc..3e3d100ed 100644
--- a/pandas-stubs/core/tools/numeric.pyi
+++ b/pandas-stubs/core/tools/numeric.pyi
@@ -1,11 +1,11 @@
 from typing import (
     Literal,
+    TypeAlias,
     overload,
 )
 
 import numpy as np
 import pandas as pd
-from typing_extensions import TypeAlias
 
 from pandas._libs.lib import _NoDefaultDoNotUse
 from pandas._typing import (
diff --git a/pandas-stubs/io/formats/style_render.pyi b/pandas-stubs/io/formats/style_render.pyi
index 04c268010..fec6219c1 100644
--- a/pandas-stubs/io/formats/style_render.pyi
+++ b/pandas-stubs/io/formats/style_render.pyi
@@ -5,6 +5,7 @@ from collections.abc import (
 from typing import (
     Any,
     Literal,
+    TypeAlias,
     TypedDict,
 )
 
@@ -15,10 +16,7 @@ from jinja2.environment import (
 from jinja2.loaders import PackageLoader
 from pandas import Index
 from pandas.core.indexing import _IndexSlice
-from typing_extensions import (
-    Self,
-    TypeAlias,
-)
+from typing_extensions import Self
 
 from pandas._typing import (
     Axis,
diff --git a/pandas-stubs/io/sql.pyi b/pandas-stubs/io/sql.pyi
index 49ea7b0e3..5dadb15c7 100644
--- a/pandas-stubs/io/sql.pyi
+++ b/pandas-stubs/io/sql.pyi
@@ -8,6 +8,7 @@ import sqlite3
 from typing import (
     Any,
     Literal,
+    TypeAlias,
     overload,
 )
 
@@ -15,7 +16,6 @@ from pandas.core.frame import DataFrame
 import sqlalchemy.engine
 from sqlalchemy.orm import FromStatement
 import sqlalchemy.sql.expression
-from typing_extensions import TypeAlias
 
 from pandas._libs.lib import _NoDefaultDoNotUse
 from pandas._typing import (
diff --git a/pandas-stubs/plotting/_core.pyi b/pandas-stubs/plotting/_core.pyi
index df3237fa2..f36c48c1c 100644
--- a/pandas-stubs/plotting/_core.pyi
+++ b/pandas-stubs/plotting/_core.pyi
@@ -8,6 +8,7 @@ from typing import (
     Any,
     Literal,
     NamedTuple,
+    TypeAlias,
     overload,
 )
 
@@ -19,7 +20,6 @@ import pandas as pd
 from pandas import Series
 from pandas.core.frame import DataFrame
 from scipy.stats import gaussian_kde
-from typing_extensions import TypeAlias
 
 from pandas._typing import (
     ArrayLike,
diff --git a/pandas-stubs/plotting/_misc.pyi b/pandas-stubs/plotting/_misc.pyi
index c52ca2569..3a8965502 100644
--- a/pandas-stubs/plotting/_misc.pyi
+++ b/pandas-stubs/plotting/_misc.pyi
@@ -5,6 +5,7 @@ from collections.abc import (
 from typing import (
     Any,
     Literal,
+    TypeAlias,
 )
 
 from matplotlib.axes import Axes
@@ -14,7 +15,6 @@ from matplotlib.table import Table
 import numpy as np
 from pandas.core.frame import DataFrame
 from pandas.core.series import Series
-from typing_extensions import TypeAlias
 
 from pandas._typing import (
     HashableT,
diff --git a/pyproject.toml b/pyproject.toml
index f98dd1195..a9f5bda73 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -138,7 +138,7 @@ args = [
 
 
 [tool.black]
-target-version = ['py310']
+target-version = ["py310"]
 
 [tool.isort]
 known_pre_libs = "pandas._config"
@@ -168,6 +168,25 @@ force_grid_wrap = 2
 force_sort_within_sections = true
 skip_glob = "env"
 
+
+[tool.ruff]
+target-version = "py310"
+fix = true
+
+
+[tool.ruff.lint]
+extend-select = ["B007", "B018", "PYI", "UP", "RUF100", "RUF059"]
+ignore = [
+  "E501",   # https://docs.astral.sh/ruff/rules/line-too-long/
+  "E731",   # https://docs.astral.sh/ruff/rules/lambda-assignment/
+  "PYI042", # https://docs.astral.sh/ruff/rules/snake-case-type-alias/
+]
+
+
+[tool.ruff.lint.per-file-ignores]
+"_*.pyi" = ["PYI001"]
+
+
 [tool.mypy]
 # Import discovery
 namespace_packages = false
@@ -224,12 +243,10 @@ reportMissingTypeArgument = false
 reportMissingTypeStubs = false
 reportUnnecessaryTypeIgnoreComment = true
 reportUnknownArgumentType = false
-reportUnusedExpression = false
 reportUnknownLambdaType = false
 reportUnknownMemberType = false
 reportUnknownParameterType = false
 reportUnknownVariableType = false
-reportUnusedVariable = false
 reportPrivateUsage = false
 # enable optional checks
 reportMissingModuleSource = true
diff --git a/scripts/_job.py b/scripts/_job.py
index c3d22dbf8..3a222bb03 100644
--- a/scripts/_job.py
+++ b/scripts/_job.py
@@ -1,11 +1,8 @@
 from collections import deque
+from collections.abc import Callable
 from dataclasses import dataclass
 import sys
 import time
-from typing import (
-    Callable,
-    Optional,
-)
 
 from loguru import logger
 
@@ -14,7 +11,7 @@
 class Step:
     name: str
     run: Callable[[], None]
-    rollback: Optional[Callable[[], None]] = None
+    rollback: Callable[[], None] | None = None
 
 
 def __rollback_job(steps: deque[Step]):
diff --git a/tests/indexes/test_indexes.py b/tests/indexes/test_indexes.py
index ce3296d0d..af88f9116 100644
--- a/tests/indexes/test_indexes.py
+++ b/tests/indexes/test_indexes.py
@@ -1289,10 +1289,10 @@ def test_timedelta_div() -> None:
     check(assert_type([delta] // index, "pd.Index[int]"), pd.Index, np.signedinteger)
 
     if TYPE_CHECKING_INVALID_USAGE:
-        1 / index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        [1] / index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        1 // index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        [1] // index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _0 = 1 / index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _1 = [1] / index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _2 = 1 // index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _3 = [1] // index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
 
 
 def test_datetime_operators_builtin() -> None:
@@ -1310,22 +1310,20 @@ def test_datetime_operators_builtin() -> None:
 def test_get_loc() -> None:
     unique_index = pd.Index(list("abc"))
     check(
-        assert_type(unique_index.get_loc("b"), Union[int, slice, np_1darray[np.bool]]),
+        assert_type(unique_index.get_loc("b"), int | slice | np_1darray[np.bool]),
         int,
     )
 
     monotonic_index = pd.Index(list("abbc"))
     check(
-        assert_type(
-            monotonic_index.get_loc("b"), Union[int, slice, np_1darray[np.bool]]
-        ),
+        assert_type(monotonic_index.get_loc("b"), int | slice | np_1darray[np.bool]),
         slice,
     )
 
     non_monotonic_index = pd.Index(list("abcb"))
     check(
         assert_type(
-            non_monotonic_index.get_loc("b"), Union[int, slice, np_1darray[np.bool]]
+            non_monotonic_index.get_loc("b"), int | slice | np_1darray[np.bool]
         ),
         np_1darray[np.bool],
     )
@@ -1334,14 +1332,14 @@ def test_get_loc() -> None:
     unique_interval_index = pd.IntervalIndex([i1, i2])
     check(
         assert_type(
-            unique_interval_index.get_loc(i1), Union[int, slice, np_1darray[np.bool]]
+            unique_interval_index.get_loc(i1), int | slice | np_1darray[np.bool]
         ),
         np.int64,
     )
     overlap_interval_index = pd.IntervalIndex([i1, i2, i3])
     check(
         assert_type(
-            overlap_interval_index.get_loc(1), Union[int, slice, np_1darray[np.bool]]
+            overlap_interval_index.get_loc(1), int | slice | np_1darray[np.bool]
         ),
         np_1darray[np.bool],
     )
@@ -1379,7 +1377,7 @@ def test_index_categorical() -> None:
 def test_disallow_empty_index() -> None:
     # From GH 826
     if TYPE_CHECKING_INVALID_USAGE:
-        i0 = pd.Index()  # type: ignore[call-overload] # pyright: ignore[reportCallIssue]
+        _0 = pd.Index()  # type: ignore[call-overload] # pyright: ignore[reportCallIssue]
 
 
 def test_datetime_index_max_min_reductions() -> None:
diff --git a/tests/scalars/test_scalars.py b/tests/scalars/test_scalars.py
index 54fcb08c5..251dab4d3 100644
--- a/tests/scalars/test_scalars.py
+++ b/tests/scalars/test_scalars.py
@@ -5,7 +5,7 @@
 from typing import (
     Any,
     Literal,
-    Optional,
+    TypeAlias,
 )
 
 import dateutil.tz
@@ -15,7 +15,6 @@
 from pandas.api.typing import NaTType
 import pytz
 from typing_extensions import (
-    TypeAlias,
     assert_type,
 )
 
@@ -599,14 +598,14 @@ def test_timedelta_add_sub() -> None:
     # TypeError: as_period, as_timestamp, as_datetime, as_date, as_datetime64,
     #            as_period_index, as_datetime_index, as_ndarray_dt64
     if TYPE_CHECKING_INVALID_USAGE:
-        td - as_period  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        td - as_timestamp  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        td - as_datetime  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        td - as_date  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        td - as_datetime64  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        td - as_period_index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        td - as_datetime_index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        td - as_ndarray_dt64  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _0 = td - as_period  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _1 = td - as_timestamp  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _2 = td - as_datetime  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _3 = td - as_date  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _4 = td - as_datetime64  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _5 = td - as_period_index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _6 = td - as_datetime_index  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _7 = td - as_ndarray_dt64  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
 
     check(assert_type(td - td, pd.Timedelta), pd.Timedelta)
     check(assert_type(td - as_dt_timedelta, pd.Timedelta), pd.Timedelta)
@@ -778,14 +777,14 @@ def test_timedelta_mul_div() -> None:
     # TypeError: md_int, md_float, md_ndarray_intp, md_ndarray_float, mp_series_int,
     #            mp_series_float, md_int64_index, md_float_index
     if TYPE_CHECKING_INVALID_USAGE:
-        md_int // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_float // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_ndarray_intp // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_ndarray_float // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        mp_series_int // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_series_float // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_int64_index // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_float_index // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _00 = md_int // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _01 = md_float // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _02 = md_ndarray_intp // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _03 = md_ndarray_float // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _04 = mp_series_int // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _05 = md_series_float // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _06 = md_int64_index // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _07 = md_float_index // td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
 
     check(assert_type(td / td, float), float)
     check(assert_type(td / pd.NaT, float), float)
@@ -820,14 +819,14 @@ def test_timedelta_mul_div() -> None:
     # TypeError: md_int, md_float, md_ndarray_intp, md_ndarray_float, mp_series_int,
     #            mp_series_float, md_int64_index, md_float_index
     if TYPE_CHECKING_INVALID_USAGE:
-        md_int / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_float / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_ndarray_intp / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_ndarray_float / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        mp_series_int / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_series_float / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_int64_index / td,  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        md_float_index / td,  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _10 = md_int / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _11 = md_float / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _12 = md_ndarray_intp / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _13 = md_ndarray_float / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _14 = mp_series_int / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _15 = md_series_float / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _16 = (md_int64_index / td,)  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _17 = (md_float_index / td,)  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
 
 
 def test_timedelta_mod_abs_unary() -> None:
@@ -1160,7 +1159,7 @@ def test_timestamp_properties() -> None:
     check(assert_type(ts.is_year_end, bool), bool)
     check(assert_type(ts.is_year_start, bool), bool)
     check(assert_type(ts.quarter, int), int)
-    check(assert_type(ts.tz, Optional[dt.tzinfo]), type(None))
+    check(assert_type(ts.tz, dt.tzinfo | None), type(None))
     check(assert_type(ts.week, int), int)
     check(assert_type(ts.weekofyear, int), int)
     check(assert_type(ts.day, int), int)
@@ -1171,7 +1170,7 @@ def test_timestamp_properties() -> None:
     check(assert_type(ts.month, int), int)
     check(assert_type(ts.nanosecond, int), int)
     check(assert_type(ts.second, int), int)
-    check(assert_type(ts.tzinfo, Optional[dt.tzinfo]), type(None))
+    check(assert_type(ts.tzinfo, dt.tzinfo | None), type(None))
     check(assert_type(ts.value, int), int)
     check(assert_type(ts.year, int), int)
     check(assert_type(ts.unit, TimeUnit), str)
@@ -2109,5 +2108,5 @@ def test_period_methods() -> None:
 
 def test_nattype_hashable() -> None:
     # GH 827
-    aset = {pd.NaT}
+    _aset = {pd.NaT}
     check(assert_type(pd.NaT.__hash__(), int), int)
diff --git a/tests/series/arithmetic/test_mul.py b/tests/series/arithmetic/test_mul.py
index f89633416..65ab42f0d 100644
--- a/tests/series/arithmetic/test_mul.py
+++ b/tests/series/arithmetic/test_mul.py
@@ -177,7 +177,7 @@ def test_mul_str_py_str() -> None:
     s = "abc"
 
     if TYPE_CHECKING_INVALID_USAGE:
-        left_i * s  # type: ignore[operator] # pyright:ignore[reportOperatorIssue]
-        s * left_i  # type: ignore[operator] # pyright:ignore[reportOperatorIssue]
+        _0 = left_i * s  # type: ignore[operator] # pyright:ignore[reportOperatorIssue]
+        _1 = s * left_i  # type: ignore[operator] # pyright:ignore[reportOperatorIssue]
         left_i.mul(s)  # type: ignore[type-var] # pyright: ignore[reportArgumentType,reportCallIssue]
         left_i.rmul(s)  # type: ignore[type-var] # pyright: ignore[reportArgumentType,reportCallIssue]
diff --git a/tests/series/test_series.py b/tests/series/test_series.py
index 9079708c1..0c1ae9efc 100644
--- a/tests/series/test_series.py
+++ b/tests/series/test_series.py
@@ -18,9 +18,9 @@
     Any,
     Generic,
     Literal,
+    TypeAlias,
     TypedDict,
     TypeVar,
-    Union,
     cast,
 )
 
@@ -40,7 +40,6 @@
 from typing_extensions import (
     Never,
     Self,
-    TypeAlias,
     assert_type,
 )
 import xarray as xr
@@ -310,16 +309,20 @@ def test_types_drop() -> None:
 
 def test_arguments_drop() -> None:
     # GH 950
+    s = pd.Series([0, 1, 2])
     if TYPE_CHECKING_INVALID_USAGE:
-        s = pd.Series([0, 1, 2])
-        res1 = s.drop()  # type: ignore[call-overload] # pyright: ignore[reportCallIssue]
-        res2 = s.drop([0], columns=["col1"])  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
-        res3 = s.drop([0], index=[0])  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
-        # These should also fail, but `None` is Hasheable and i do not know how
-        # to type hint a non-None hashable.
-        # res4 = s.drop(columns=None)
-        # res5 = s.drop(index=None)
-        # res6 = s.drop(None)
+        _res1 = s.drop()  # type: ignore[call-overload] # pyright: ignore[reportCallIssue]
+        _res2 = s.drop([0], columns=["col1"])  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
+        _res3 = s.drop([0], index=[0])  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
+
+    def _never_checker0() -> None:  # pyright: ignore[reportUnusedFunction]
+        assert_type(s.drop(columns=None), Never)
+
+    def _never_checker1() -> None:  # pyright: ignore[reportUnusedFunction]
+        assert_type(s.drop(index=None), Never)
+
+    def _never_checker2() -> None:  # pyright: ignore[reportUnusedFunction]
+        assert_type(s.drop(None), Never)
 
 
 def test_types_drop_multilevel() -> None:
@@ -817,14 +820,14 @@ def test_types_element_wise_arithmetic() -> None:
         assert_type(s.div(s2, fill_value=0), "pd.Series[float]"), pd.Series, np.float64
     )
 
-    res_floordiv: pd.Series = s // s2
-    res_floordiv2: pd.Series = s.floordiv(s2, fill_value=0)
+    _res_floordiv: pd.Series = s // s2
+    _res_floordiv2: pd.Series = s.floordiv(s2, fill_value=0)
 
-    res_mod: pd.Series = s % s2
-    res_mod2: pd.Series = s.mod(s2, fill_value=0)
+    _res_mod: pd.Series = s % s2
+    _res_mod2: pd.Series = s.mod(s2, fill_value=0)
 
-    res_pow: pd.Series = s ** s2.abs()
-    res_pow2: pd.Series = s.pow(s2.abs(), fill_value=0)
+    _res_pow: pd.Series = s ** s2.abs()
+    _res_pow2: pd.Series = s.pow(s2.abs(), fill_value=0)
 
     check(assert_type(divmod(s, s2), tuple["pd.Series[int]", "pd.Series[int]"]), tuple)
 
@@ -847,16 +850,16 @@ def test_types_scalar_arithmetic() -> None:
         assert_type(s.div(2, fill_value=0), "pd.Series[float]"), pd.Series, np.floating
     )
 
-    res_floordiv: pd.Series = s // 2
-    res_floordiv2: pd.Series = s.floordiv(2, fill_value=0)
+    _res_floordiv: pd.Series = s // 2
+    _res_floordiv2: pd.Series = s.floordiv(2, fill_value=0)
 
-    res_mod: pd.Series = s % 2
-    res_mod2: pd.Series = s.mod(2, fill_value=0)
+    _res_mod: pd.Series = s % 2
+    _res_mod2: pd.Series = s.mod(2, fill_value=0)
 
-    res_pow: pd.Series = s**2
-    res_pow1: pd.Series = s**0
-    res_pow2: pd.Series = s**0.213
-    res_pow3: pd.Series = s.pow(0.5)
+    _res_pow: pd.Series = s**2
+    _res_pow1: pd.Series = s**0
+    _res_pow2: pd.Series = s**0.213
+    _res_pow3: pd.Series = s.pow(0.5)
 
 
 def test_types_groupby() -> None:
@@ -945,13 +948,13 @@ def test_groupby_result() -> None:
     check(assert_type(value4, "pd.Series[int]"), pd.Series, np.integer)
 
     # Want to make sure these cases are differentiated
-    for (k1, k2), g in s.groupby(["a", "b"]):
+    for (_k1, _k2), _g in s.groupby(["a", "b"]):
         pass
 
-    for kk, g in s.groupby("a"):
+    for _kk, _g in s.groupby("a"):
         pass
 
-    for (k1, k2), g in s.groupby(multi_index):
+    for (_k1, _k2), _g in s.groupby(multi_index):
         pass
 
 
@@ -1009,16 +1012,16 @@ def test_groupby_result_for_scalar_indexes() -> None:
     check(assert_type(index4, "pd.Interval[pd.Timestamp]"), pd.Interval)
     check(assert_type(value4, "pd.Series[int]"), pd.Series, np.integer)
 
-    for p, g in s.groupby(period_index):
+    for _p, _g in s.groupby(period_index):
         pass
 
-    for dt, g in s.groupby(dt_index):
+    for _dt, _g in s.groupby(dt_index):
         pass
 
-    for tdelta, g in s.groupby(tdelta_index):
+    for _tdelta, _g in s.groupby(tdelta_index):
         pass
 
-    for interval, g in s.groupby(interval_index):
+    for _interval, _g in s.groupby(interval_index):
         pass
 
 
@@ -1405,7 +1408,7 @@ def test_types_rename_axis() -> None:
 
 def test_types_values() -> None:
     check(
-        assert_type(pd.Series([1, 2, 3]).values, Union[ExtensionArray, np.ndarray]),
+        assert_type(pd.Series([1, 2, 3]).values, ExtensionArray | np.ndarray),
         np.ndarray,
     )
     valresult_type: type[np.ndarray | ExtensionArray]
@@ -1414,20 +1417,20 @@ def test_types_values() -> None:
     else:
         valresult_type = ExtensionArray
     check(
-        assert_type(pd.Series(list("aabc")).values, Union[np.ndarray, ExtensionArray]),
+        assert_type(pd.Series(list("aabc")).values, np.ndarray | ExtensionArray),
         valresult_type,
     )
     check(
         assert_type(
             pd.Series(list("aabc")).astype("category").values,
-            Union[np.ndarray, ExtensionArray],
+            np.ndarray | ExtensionArray,
         ),
         pd.Categorical,
     )
     check(
         assert_type(
             pd.Series(pd.date_range("20130101", periods=3, tz="US/Eastern")).values,
-            Union[np.ndarray, ExtensionArray],
+            np.ndarray | ExtensionArray,
         ),
         np.ndarray,
     )
@@ -1478,7 +1481,7 @@ def add1(x: int) -> int:
     )
 
     if TYPE_CHECKING_INVALID_USAGE:
-        s7 = pd.Series([1, 2, 3]).rename({1: [3, 4, 5]})  # type: ignore[dict-item] # pyright: ignore[reportArgumentType]
+        _s7 = pd.Series([1, 2, 3]).rename({1: [3, 4, 5]})  # type: ignore[dict-item] # pyright: ignore[reportArgumentType]
 
 
 def test_types_ne() -> None:
@@ -1606,7 +1609,7 @@ def test_series_multiindex_getitem() -> None:
     s = pd.Series(
         [1, 2, 3, 4], index=pd.MultiIndex.from_product([["a", "b"], ["x", "y"]])
     )
-    s1: pd.Series = s["a", :]
+    _s1: pd.Series = s["a", :]
 
 
 def test_reset_index() -> None:
@@ -1800,7 +1803,7 @@ def test_iloc_setitem_ndarray() -> None:
 
 def test_types_iter() -> None:
     s = pd.Series([1, 2, 3], dtype=int)
-    iterable: Iterable[int] = s
+    _iterable: Iterable[int] = s
     check(assert_type(iter(s), Iterator[int]), Iterator, int)
     check(assert_type(next(iter(s)), int), int)
 
@@ -1931,12 +1934,12 @@ def test_resample() -> None:
 def test_squeeze() -> None:
     s1 = pd.Series([1, 2, 3])
     check(
-        assert_type(s1.squeeze(), Union["pd.Series[int]", Scalar]),
+        assert_type(s1.squeeze(), "pd.Series[int] | Scalar"),
         pd.Series,
         np.integer,
     )
     s2 = pd.Series([1])
-    check(assert_type(s2.squeeze(), Union["pd.Series[int]", Scalar]), np.integer)
+    check(assert_type(s2.squeeze(), "pd.Series[int] | Scalar"), np.integer)
 
 
 def test_to_xarray():
@@ -3114,7 +3117,7 @@ def test_to_json_mode() -> None:
     check(assert_type(result2, str), str)
     check(assert_type(result4, str), str)
     if TYPE_CHECKING_INVALID_USAGE:
-        result3 = s.to_json(orient="records", lines=False, mode="a")  # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue]
+        _result3 = s.to_json(orient="records", lines=False, mode="a")  # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue]
 
 
 def test_groupby_diff() -> None:
@@ -3231,21 +3234,21 @@ def test_round() -> None:
 def test_get() -> None:
     s_int = pd.Series([1, 2, 3], index=[1, 2, 3])
 
-    check(assert_type(s_int.get(1), Union[int, None]), np.int64)
-    check(assert_type(s_int.get(99), Union[int, None]), type(None))
-    check(assert_type(s_int.get(1, default=None), Union[int, None]), np.int64)
-    check(assert_type(s_int.get(99, default=None), Union[int, None]), type(None))
+    check(assert_type(s_int.get(1), int | None), np.int64)
+    check(assert_type(s_int.get(99), int | None), type(None))
+    check(assert_type(s_int.get(1, default=None), int | None), np.int64)
+    check(assert_type(s_int.get(99, default=None), int | None), type(None))
     check(assert_type(s_int.get(1, default=2), int), np.int64)
-    check(assert_type(s_int.get(99, default="a"), Union[int, str]), str)
+    check(assert_type(s_int.get(99, default="a"), int | str), str)
 
     s_str = pd.Series(list("abc"), index=list("abc"))
 
-    check(assert_type(s_str.get("a"), Union[str, None]), str)
-    check(assert_type(s_str.get("z"), Union[str, None]), type(None))
-    check(assert_type(s_str.get("a", default=None), Union[str, None]), str)
-    check(assert_type(s_str.get("z", default=None), Union[str, None]), type(None))
+    check(assert_type(s_str.get("a"), str | None), str)
+    check(assert_type(s_str.get("z"), str | None), type(None))
+    check(assert_type(s_str.get("a", default=None), str | None), str)
+    check(assert_type(s_str.get("z", default=None), str | None), type(None))
     check(assert_type(s_str.get("a", default="b"), str), str)
-    check(assert_type(s_str.get("z", default=True), Union[str, bool]), bool)
+    check(assert_type(s_str.get("z", default=True), str | bool), bool)
 
 
 def test_series_new_empty() -> None:
@@ -3730,7 +3733,7 @@ def test_series_bool_fails() -> None:
         # mypy doesn't seem to figure that out, but pyright does
         if s == "foo":  # pyright: ignore[reportGeneralTypeIssues]
             # Next line is unreachable.
-            a = s[0]
+            _a = s[0]
             assert False
     except ValueError:
         pass
@@ -3879,11 +3882,10 @@ def test_cumsum_timedelta() -> None:
 def test_series_unstack() -> None:
     df = pd.DataFrame([[1, 3, 5], [2, 4, 6]])
     s = df.transpose().stack([*range(df.index.nlevels)])
-    check(assert_type(s, Union[pd.Series, pd.DataFrame]), pd.Series)
+    check(assert_type(s, pd.Series | pd.DataFrame), pd.Series)
     check(
         assert_type(
-            s.unstack([*range(s.index.nlevels // 2)]),
-            Union[pd.Series, pd.DataFrame],
+            s.unstack([*range(s.index.nlevels // 2)]), pd.Series | pd.DataFrame
         ),
         pd.DataFrame,
     )
@@ -3905,7 +3907,7 @@ def test_series_index_type() -> None:
     )
 
     if TYPE_CHECKING_INVALID_USAGE:
-        t = pd.Series([1, 2], index="ab")  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
+        _t = pd.Series([1, 2], index="ab")  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
 
 
 def test_timedelta_index_cumprod() -> None:
diff --git a/tests/test_api_typing.py b/tests/test_api_typing.py
index 358d3acca..8140e778d 100644
--- a/tests/test_api_typing.py
+++ b/tests/test_api_typing.py
@@ -1,5 +1,7 @@
 """Test module for classes in pandas.api.typing."""
 
+from typing import TypeAlias
+
 import numpy as np
 import pandas as pd
 from pandas import read_json
@@ -25,7 +27,6 @@
 )
 import pytest
 from typing_extensions import (
-    TypeAlias,
     assert_type,
 )
 
diff --git a/tests/test_config.py b/tests/test_config.py
index a8f5dbe4a..a18773631 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -1,9 +1,8 @@
+from collections.abc import Callable
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Literal,
-    Optional,
 )
 
 import pandas as pd
@@ -43,7 +42,7 @@ def test_specific_option():
 
 def test_display_float_format():
     check(
-        assert_type(pd.options.display.float_format, Optional[Callable[[float], str]]),
+        assert_type(pd.options.display.float_format, Callable[[float], str] | None),
         type(None),
     )
     formatter = "{,.2f}".format
@@ -54,13 +53,13 @@ def test_display_float_format():
 def test_display_types_none_allowed_get_options():
     # GH 1230
     # Initial values
-    check(assert_type(pd.options.display.chop_threshold, Optional[float]), type(None))
-    check(assert_type(pd.options.display.max_columns, Optional[int]), int)
-    check(assert_type(pd.options.display.max_colwidth, Optional[int]), int)
-    check(assert_type(pd.options.display.max_dir_items, Optional[int]), int)
-    check(assert_type(pd.options.display.max_rows, Optional[int]), int)
-    check(assert_type(pd.options.display.max_seq_items, Optional[int]), int)
-    check(assert_type(pd.options.display.min_rows, Optional[int]), int)
+    check(assert_type(pd.options.display.chop_threshold, float | None), type(None))
+    check(assert_type(pd.options.display.max_columns, int | None), int)
+    check(assert_type(pd.options.display.max_colwidth, int | None), int)
+    check(assert_type(pd.options.display.max_dir_items, int | None), int)
+    check(assert_type(pd.options.display.max_rows, int | None), int)
+    check(assert_type(pd.options.display.max_seq_items, int | None), int)
+    check(assert_type(pd.options.display.min_rows, int | None), int)
 
 
 def test_display_types_none_allowed_set_options():
@@ -100,7 +99,7 @@ def test_display_types_literal_constraints():
     check(assert_type(pd.options.display.large_repr, Literal["info"]), str)
 
     # Test memory_usage with allowed values
-    assert_type(pd.options.display.memory_usage, Optional[Literal[True, False, "deep"]])
+    assert_type(pd.options.display.memory_usage, Literal[True, False, "deep"] | None)
     pd.options.display.memory_usage = True
     check(assert_type(pd.options.display.memory_usage, Literal[True]), bool)
     pd.options.display.memory_usage = False
diff --git a/tests/test_dtypes.py b/tests/test_dtypes.py
index cf6e335b6..dbf3e5fe2 100644
--- a/tests/test_dtypes.py
+++ b/tests/test_dtypes.py
@@ -7,8 +7,6 @@
 )
 from typing import (
     Literal,
-    Optional,
-    Union,
 )
 
 import numpy as np
@@ -113,7 +111,7 @@ def test_categorical_dtype() -> None:
         pd.CategoricalDtype,
     )
     check(assert_type(cdt.categories, pd.Index), pd.Index)
-    check(assert_type(cdt.ordered, Optional[bool]), bool)
+    check(assert_type(cdt.ordered, bool | None), bool)
 
 
 def test_sparse_dtype() -> None:
@@ -129,7 +127,7 @@ def test_sparse_dtype() -> None:
     check(assert_type(pd.SparseDtype(np.timedelta64), pd.SparseDtype), pd.SparseDtype)
     check(assert_type(pd.SparseDtype("datetime64"), pd.SparseDtype), pd.SparseDtype)
     check(assert_type(pd.SparseDtype(), pd.SparseDtype), pd.SparseDtype)
-    check(assert_type(s_dt.fill_value, Union[Scalar, None]), int)
+    check(assert_type(s_dt.fill_value, Scalar | None), int)
 
 
 def test_string_dtype() -> None:
diff --git a/tests/test_frame.py b/tests/test_frame.py
index e16a973fd..82de306c3 100644
--- a/tests/test_frame.py
+++ b/tests/test_frame.py
@@ -25,9 +25,9 @@
     TYPE_CHECKING,
     Any,
     Generic,
+    TypeAlias,
     TypedDict,
     TypeVar,
-    Union,
     cast,
 )
 
@@ -42,7 +42,6 @@
 import pytest
 from typing_extensions import (
     Never,
-    TypeAlias,
     assert_never,
     assert_type,
 )
@@ -177,22 +176,22 @@ def test_types_append() -> None:
     df = pd.DataFrame(data={"col1": [1, 2], "col2": [3, 4]})
     df2 = pd.DataFrame({"col1": [10, 20], "col2": [30, 40]})
     if TYPE_CHECKING_INVALID_USAGE:
-        res1: pd.DataFrame = df.append(df2)  # type: ignore[operator] # pyright: ignore[reportCallIssue]
-        res2: pd.DataFrame = df.append([1, 2, 3])  # type: ignore[operator] # pyright: ignore[reportCallIssue]
-        res3: pd.DataFrame = df.append([[1, 2, 3]])  # type: ignore[operator] # pyright: ignore[reportCallIssue]
-        res4: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
+        _res1: pd.DataFrame = df.append(df2)  # type: ignore[operator] # pyright: ignore[reportCallIssue]
+        _res2: pd.DataFrame = df.append([1, 2, 3])  # type: ignore[operator] # pyright: ignore[reportCallIssue]
+        _res3: pd.DataFrame = df.append([[1, 2, 3]])  # type: ignore[operator] # pyright: ignore[reportCallIssue]
+        _res4: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
             {("a", 1): [1, 2, 3], "b": df2}, ignore_index=True
         )
-        res5: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
+        _res5: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
             {1: [1, 2, 3]}, ignore_index=True
         )
-        res6: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
+        _res6: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
             {1: [1, 2, 3], "col2": [1, 2, 3]}, ignore_index=True
         )
-        res7: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
+        _res7: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
             pd.Series([5, 6]), ignore_index=True
         )
-        res8: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
+        _res8: pd.DataFrame = df.append(  # type: ignore[operator] # pyright: ignore[reportCallIssue]
             pd.Series([5, 6], index=["col1", "col2"]), ignore_index=True
         )
 
@@ -478,16 +477,20 @@ def test_types_drop() -> None:
 
 def test_arguments_drop() -> None:
     # GH 950
+    df = pd.DataFrame(data={"col1": [1, 2], "col2": [3, 4]})
     if TYPE_CHECKING_INVALID_USAGE:
-        df = pd.DataFrame(data={"col1": [1, 2], "col2": [3, 4]})
-        res1 = df.drop()  # type: ignore[call-overload] # pyright: ignore[reportCallIssue]
-        res2 = df.drop([0], columns=["col1"])  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
-        res3 = df.drop([0], index=[0])  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
-        # These should also fail, but `None` is Hasheable and i do not know how
-        # to type hint a non-None hashable.
-        # res4 = df.drop(columns=None)
-        # res5 = df.drop(index=None)
-        # res6 = df.drop(None)
+        _res1 = df.drop()  # type: ignore[call-overload] # pyright: ignore[reportCallIssue]
+        _res2 = df.drop([0], columns=["col1"])  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
+        _res3 = df.drop([0], index=[0])  # type: ignore[call-overload] # pyright: ignore[reportCallIssue, reportArgumentType]
+
+    def _never_checker0() -> None:  # pyright: ignore[reportUnusedFunction]
+        assert_type(df.drop(columns=None), Never)
+
+    def _never_checker1() -> None:  # pyright: ignore[reportUnusedFunction]
+        assert_type(df.drop(index=None), Never)
+
+    def _never_checker2() -> None:  # pyright: ignore[reportUnusedFunction]
+        assert_type(df.drop(None), Never)
 
 
 def test_types_dropna() -> None:
@@ -2805,7 +2808,7 @@ def test_groupby_series_methods() -> None:
     check(assert_type(gb.min(), pd.Series), pd.Series)
     check(assert_type(gb.nlargest(), pd.Series), pd.Series)
     check(assert_type(gb.nsmallest(), pd.Series), pd.Series)
-    check(assert_type(gb.nth(0), Union[pd.DataFrame, pd.Series]), pd.Series)
+    check(assert_type(gb.nth(0), pd.DataFrame | pd.Series), pd.Series)
 
 
 def test_dataframe_pct_change() -> None:
@@ -3194,13 +3197,13 @@ def test_frame_stack() -> None:
         upper="2.3.99",
     ):
         check(
-            assert_type(df_multi_level_cols2.stack(0), Union[pd.DataFrame, pd.Series]),
+            assert_type(df_multi_level_cols2.stack(0), pd.DataFrame | pd.Series),
             pd.DataFrame,
         )
         check(
             assert_type(
                 df_multi_level_cols2.stack([0, 1]),
-                Union[pd.DataFrame, pd.Series],
+                pd.DataFrame | pd.Series,
             ),
             pd.Series,
         )
@@ -3208,14 +3211,14 @@ def test_frame_stack() -> None:
             check(
                 assert_type(
                     df_multi_level_cols2.stack(0, future_stack=False),
-                    Union[pd.DataFrame, pd.Series],
+                    pd.DataFrame | pd.Series,
                 ),
                 pd.DataFrame,
             )
             check(
                 assert_type(
                     df_multi_level_cols2.stack(0, dropna=True, sort=True),
-                    Union[pd.DataFrame, pd.Series],
+                    pd.DataFrame | pd.Series,
                 ),
                 pd.DataFrame,
             )
@@ -3346,16 +3349,16 @@ def test_frame_scalars_slice() -> None:
 
     # Note: bool_ cannot be tested since the index is object and pandas does not
     # support boolean access using loc except when the index is boolean
-    check(assert_type(df.loc[str_], Union[pd.Series, pd.DataFrame]), pd.Series)
-    check(assert_type(df.loc[bytes_], Union[pd.Series, pd.DataFrame]), pd.Series)
-    check(assert_type(df.loc[date], Union[pd.Series, pd.DataFrame]), pd.Series)
-    check(assert_type(df.loc[datetime_], Union[pd.Series, pd.DataFrame]), pd.Series)
-    check(assert_type(df.loc[timedelta], Union[pd.Series, pd.DataFrame]), pd.Series)
-    check(assert_type(df.loc[int_], Union[pd.Series, pd.DataFrame]), pd.Series)
-    check(assert_type(df.loc[float_], Union[pd.Series, pd.DataFrame]), pd.Series)
-    check(assert_type(df.loc[complex_], Union[pd.Series, pd.DataFrame]), pd.Series)
-    check(assert_type(df.loc[timestamp], Union[pd.Series, pd.DataFrame]), pd.Series)
-    check(assert_type(df.loc[pd_timedelta], Union[pd.Series, pd.DataFrame]), pd.Series)
+    check(assert_type(df.loc[str_], pd.Series | pd.DataFrame), pd.Series)
+    check(assert_type(df.loc[bytes_], pd.Series | pd.DataFrame), pd.Series)
+    check(assert_type(df.loc[date], pd.Series | pd.DataFrame), pd.Series)
+    check(assert_type(df.loc[datetime_], pd.Series | pd.DataFrame), pd.Series)
+    check(assert_type(df.loc[timedelta], pd.Series | pd.DataFrame), pd.Series)
+    check(assert_type(df.loc[int_], pd.Series | pd.DataFrame), pd.Series)
+    check(assert_type(df.loc[float_], pd.Series | pd.DataFrame), pd.Series)
+    check(assert_type(df.loc[complex_], pd.Series | pd.DataFrame), pd.Series)
+    check(assert_type(df.loc[timestamp], pd.Series | pd.DataFrame), pd.Series)
+    check(assert_type(df.loc[pd_timedelta], pd.Series | pd.DataFrame), pd.Series)
     check(assert_type(df.loc[none], pd.Series), pd.Series)
 
     check(assert_type(df.loc[:, str_], pd.Series), pd.Series)
@@ -3374,10 +3377,10 @@ def test_frame_scalars_slice() -> None:
 
     multi_idx = pd.MultiIndex.from_product([["a", "b"], [1, 2]], names=["alpha", "num"])
     df2 = pd.DataFrame({"col1": range(4)}, index=multi_idx)
-    check(assert_type(df2.loc[str_], Union[pd.Series, pd.DataFrame]), pd.DataFrame)
+    check(assert_type(df2.loc[str_], pd.Series | pd.DataFrame), pd.DataFrame)
 
     df3 = pd.DataFrame({"x": range(2)}, index=pd.Index(["a", "b"]))
-    check(assert_type(df3.loc[str_], Union[pd.Series, pd.DataFrame]), pd.Series)
+    check(assert_type(df3.loc[str_], pd.Series | pd.DataFrame), pd.Series)
 
     # https://github.com/microsoft/python-type-stubs/issues/62
     df7 = pd.DataFrame({"x": [1, 2, 3]}, index=pd.Index(["a", "b", "c"]))
@@ -3388,7 +3391,7 @@ def test_frame_scalars_slice() -> None:
 def test_boolean_loc() -> None:
     # Booleans can only be used in loc when the index is boolean
     df = pd.DataFrame([[0, 1], [1, 0]], columns=[True, False], index=[True, False])
-    check(assert_type(df.loc[True], Union[pd.Series, pd.DataFrame]), pd.Series)
+    check(assert_type(df.loc[True], pd.Series | pd.DataFrame), pd.Series)
     check(assert_type(df.loc[:, False], pd.Series), pd.Series)
 
 
@@ -3427,13 +3430,13 @@ def test_groupby_result() -> None:
     check(assert_type(value3, pd.DataFrame), pd.DataFrame)
 
     # Want to make sure these cases are differentiated
-    for (k1, k2), g in df.groupby(["a", "b"]):
+    for (_k1, _k2), _g in df.groupby(["a", "b"]):
         pass
 
-    for kk, g in df.groupby("a"):
+    for _kk, _g in df.groupby("a"):
         pass
 
-    for (k1, k2), g in df.groupby(multi_index):
+    for (_k1, _k2), _g in df.groupby(multi_index):
         pass
 
 
@@ -3481,16 +3484,16 @@ def test_groupby_result_for_scalar_indexes() -> None:
     check(assert_type(index4, "pd.Interval[pd.Timestamp]"), pd.Interval)
     check(assert_type(value4, pd.DataFrame), pd.DataFrame)
 
-    for p, g in df.groupby(period_index):
+    for _p, _g in df.groupby(period_index):
         pass
 
-    for dt, g in df.groupby(dt_index):
+    for _dt, _g in df.groupby(dt_index):
         pass
 
-    for tdelta, g in df.groupby(tdelta_index):
+    for _tdelta, _g in df.groupby(tdelta_index):
         pass
 
-    for interval, g in df.groupby(interval_index):
+    for _interval, _g in df.groupby(interval_index):
         pass
 
 
@@ -3657,21 +3660,17 @@ def test_resample() -> None:
 
 def test_squeeze() -> None:
     df1 = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
-    check(
-        assert_type(df1.squeeze(), Union[pd.DataFrame, pd.Series, Scalar]), pd.DataFrame
-    )
+    check(assert_type(df1.squeeze(), pd.DataFrame | pd.Series | Scalar), pd.DataFrame)
     df2 = pd.DataFrame({"a": [1, 2]})
-    check(assert_type(df2.squeeze(), Union[pd.DataFrame, pd.Series, Scalar]), pd.Series)
+    check(assert_type(df2.squeeze(), pd.DataFrame | pd.Series | Scalar), pd.Series)
     df3 = pd.DataFrame({"a": [1], "b": [2]})
     check(
-        assert_type(df3.squeeze(), Union[pd.DataFrame, pd.Series, Scalar]),
+        assert_type(df3.squeeze(), pd.DataFrame | pd.Series | Scalar),
         pd.Series,
         np.integer,
     )
     df4 = pd.DataFrame({"a": [1]})
-    check(
-        assert_type(df4.squeeze(), Union[pd.DataFrame, pd.Series, Scalar]), np.integer
-    )
+    check(assert_type(df4.squeeze(), pd.DataFrame | pd.Series | Scalar), np.integer)
 
 
 def test_loc_set() -> None:
@@ -3843,9 +3842,7 @@ def test_xs_key() -> None:
     # GH 214
     mi = pd.MultiIndex.from_product([[0, 1], [0, 1]], names=["foo", "bar"])
     df = pd.DataFrame({"x": [10, 20, 30, 40], "y": [50, 60, 70, 80]}, index=mi)
-    check(
-        assert_type(df.xs(0, level="foo"), Union[pd.DataFrame, pd.Series]), pd.DataFrame
-    )
+    check(assert_type(df.xs(0, level="foo"), pd.DataFrame | pd.Series), pd.DataFrame)
 
 
 def test_loc_slice() -> None:
@@ -3855,7 +3852,7 @@ def test_loc_slice() -> None:
         {"x": [1, 2, 3, 4]},
         index=pd.MultiIndex.from_product([[1, 2], ["a", "b"]], names=["num", "let"]),
     )
-    check(assert_type(df1.loc[1, :], Union[pd.Series, pd.DataFrame]), pd.DataFrame)
+    check(assert_type(df1.loc[1, :], pd.Series | pd.DataFrame), pd.DataFrame)
     check(assert_type(df1[::-1], pd.DataFrame), pd.DataFrame)
 
     # GH1299
@@ -4231,8 +4228,8 @@ def test_xs_frame_new() -> None:
     df = df.set_index(["class", "animal", "locomotion"])
     s1 = df.xs("mammal", axis=0)
     s2 = df.xs("num_wings", axis=1)
-    check(assert_type(s1, Union[pd.Series, pd.DataFrame]), pd.DataFrame)
-    check(assert_type(s2, Union[pd.Series, pd.DataFrame]), pd.Series)
+    check(assert_type(s1, pd.Series | pd.DataFrame), pd.DataFrame)
+    check(assert_type(s2, pd.Series | pd.DataFrame), pd.Series)
 
 
 def test_align() -> None:
@@ -4279,7 +4276,7 @@ def test_align() -> None:
 def test_loc_returns_series() -> None:
     df1 = pd.DataFrame({"x": [1, 2, 3, 4]}, index=[10, 20, 30, 40])
     df2 = df1.loc[10, :]
-    check(assert_type(df2, Union[pd.Series, pd.DataFrame]), pd.Series)
+    check(assert_type(df2, pd.Series | pd.DataFrame), pd.Series)
 
 
 def test_to_dict_index() -> None:
@@ -4404,7 +4401,7 @@ def test_to_json_mode() -> None:
     check(assert_type(result2, str), str)
     check(assert_type(result4, str), str)
     if TYPE_CHECKING_INVALID_USAGE:
-        result3 = df.to_json(orient="records", lines=False, mode="a")  # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue]
+        _result3 = df.to_json(orient="records", lines=False, mode="a")  # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue]
 
 
 def test_interpolate_inplace() -> None:
@@ -4462,35 +4459,31 @@ def test_get() -> None:
     df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
 
     # Get single column
-    check(assert_type(df.get("a"), Union[pd.Series, None]), pd.Series, np.int64)
-    check(assert_type(df.get("z"), Union[pd.Series, None]), type(None))
+    check(assert_type(df.get("a"), pd.Series | None), pd.Series, np.int64)
+    check(assert_type(df.get("z"), pd.Series | None), type(None))
     check(
-        assert_type(df.get("a", default=None), Union[pd.Series, None]),
+        assert_type(df.get("a", default=None), pd.Series | None),
         pd.Series,
         np.int64,
     )
-    check(assert_type(df.get("z", default=None), Union[pd.Series, None]), type(None))
-    check(
-        assert_type(df.get("a", default=1), Union[pd.Series, int]), pd.Series, np.int64
-    )
-    check(assert_type(df.get("z", default=1), Union[pd.Series, int]), int)
+    check(assert_type(df.get("z", default=None), pd.Series | None), type(None))
+    check(assert_type(df.get("a", default=1), pd.Series | int), pd.Series, np.int64)
+    check(assert_type(df.get("z", default=1), pd.Series | int), int)
 
     # Get multiple columns
-    check(assert_type(df.get(["a"]), Union[pd.DataFrame, None]), pd.DataFrame)
-    check(assert_type(df.get(["a", "b"]), Union[pd.DataFrame, None]), pd.DataFrame)
-    check(assert_type(df.get(["z"]), Union[pd.DataFrame, None]), type(None))
+    check(assert_type(df.get(["a"]), pd.DataFrame | None), pd.DataFrame)
+    check(assert_type(df.get(["a", "b"]), pd.DataFrame | None), pd.DataFrame)
+    check(assert_type(df.get(["z"]), pd.DataFrame | None), type(None))
     check(
-        assert_type(df.get(["a", "b"], default=None), Union[pd.DataFrame, None]),
+        assert_type(df.get(["a", "b"], default=None), pd.DataFrame | None),
         pd.DataFrame,
     )
+    check(assert_type(df.get(["z"], default=None), pd.DataFrame | None), type(None))
     check(
-        assert_type(df.get(["z"], default=None), Union[pd.DataFrame, None]), type(None)
-    )
-    check(
-        assert_type(df.get(["a", "b"], default=1), Union[pd.DataFrame, int]),
+        assert_type(df.get(["a", "b"], default=1), pd.DataFrame | int),
         pd.DataFrame,
     )
-    check(assert_type(df.get(["z"], default=1), Union[pd.DataFrame, int]), int)
+    check(assert_type(df.get(["z"], default=1), pd.DataFrame | int), int)
 
 
 def test_info() -> None:
@@ -4547,7 +4540,7 @@ def test_frame_bool_fails() -> None:
         # mypy doesn't seem to figure that out, but pyright does
         if df == "foo":  # pyright: ignore[reportGeneralTypeIssues]
             # Next line is unreachable.
-            s = df["a"]
+            _s = df["a"]
     except ValueError:
         pass
 
diff --git a/tests/test_groupby.py b/tests/test_groupby.py
index 2e478b3c0..a6f623ab3 100644
--- a/tests/test_groupby.py
+++ b/tests/test_groupby.py
@@ -5,7 +5,6 @@
 from typing import (
     TYPE_CHECKING,
     Literal,
-    Union,
     cast,
 )
 
@@ -380,37 +379,35 @@ def test_series_groupby_resample() -> None:
         upper="2.99",
     ):
         check(
-            assert_type(
-                GB_S.resample("ME").aggregate(np.sum), Union[DataFrame, Series]
-            ),
+            assert_type(GB_S.resample("ME").aggregate(np.sum), DataFrame | Series),
             Series,
         )
         check(
-            assert_type(GB_S.resample("ME").agg(np.sum), Union[DataFrame, Series]),
+            assert_type(GB_S.resample("ME").agg(np.sum), DataFrame | Series),
             Series,
         )
         check(
-            assert_type(GB_S.resample("ME").apply(np.sum), Union[DataFrame, Series]),
+            assert_type(GB_S.resample("ME").apply(np.sum), DataFrame | Series),
             Series,
         )
         check(
             assert_type(
                 GB_S.resample("ME").aggregate([np.sum, np.mean]),
-                Union[DataFrame, Series],
+                DataFrame | Series,
             ),
             DataFrame,
         )
         check(
             assert_type(
                 GB_S.resample("ME").aggregate(["sum", np.mean]),
-                Union[DataFrame, Series],
+                DataFrame | Series,
             ),
             DataFrame,
         )
         check(
             assert_type(
                 GB_S.resample("ME").aggregate({"col1": "sum", "col2": np.mean}),
-                Union[DataFrame, Series],
+                DataFrame | Series,
             ),
             DataFrame,
         )
@@ -418,9 +415,7 @@ def test_series_groupby_resample() -> None:
     def f(val: Series) -> float:
         return val.mean()
 
-    check(
-        assert_type(GB_S.resample("ME").aggregate(f), Union[DataFrame, Series]), Series
-    )
+    check(assert_type(GB_S.resample("ME").aggregate(f), DataFrame | Series), Series)
 
     # asfreq
     check(assert_type(GB_S.resample("ME").asfreq(-1.0), "Series[float]"), Series, float)
@@ -499,7 +494,7 @@ def test_frame_groupby_rolling() -> None:
 
     # props
     check(assert_type(GB_DF.rolling(1).obj, DataFrame), DataFrame)
-    check(assert_type(GB_DF.rolling(1).on, Union[str, Index, None]), type(None))
+    check(assert_type(GB_DF.rolling(1).on, str | Index | None), type(None))
     check(assert_type(GB_DF.rolling(1).method, Literal["single", "table"]), str)
     if PD_LTE_23:
         check(assert_type(GB_DF.rolling(1).axis, int), int)
@@ -694,7 +689,7 @@ def test_frame_groupby_expanding() -> None:
 
     # props
     check(assert_type(GB_DF.expanding(1).obj, DataFrame), DataFrame)
-    check(assert_type(GB_DF.expanding(1).on, Union[str, Index, None]), type(None))
+    check(assert_type(GB_DF.expanding(1).on, str | Index | None), type(None))
     check(assert_type(GB_DF.expanding(1).method, Literal["single", "table"]), str)
     if PD_LTE_23:
         check(assert_type(GB_DF.expanding(1).axis, int), int)
@@ -893,7 +888,7 @@ def test_frame_groupby_ewm() -> None:
 
     # props
     check(assert_type(GB_DF.ewm(1).obj, DataFrame), DataFrame)
-    check(assert_type(GB_DF.ewm(1).on, Union[str, Index, None]), type(None))
+    check(assert_type(GB_DF.ewm(1).on, str | Index | None), type(None))
     check(assert_type(GB_DF.ewm(1).method, Literal["single", "table"]), str)
     if PD_LTE_23:
         check(assert_type(GB_DF.ewm(1).axis, int), int)
diff --git a/tests/test_interval.py b/tests/test_interval.py
index 8d9081710..b3de71dac 100644
--- a/tests/test_interval.py
+++ b/tests/test_interval.py
@@ -85,10 +85,10 @@ def test_interval_length() -> None:
 
     check(assert_type(idres, "pd.Interval[pd.Timestamp]"), pd.Interval, pd.Timestamp)
     if TYPE_CHECKING_INVALID_USAGE:
-        20 in i1  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        i1 + pd.Timestamp("2000-03-03")  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        i1 * 3  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        i1 * pd.Timedelta(seconds=20)  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _00 = 20 in i1  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _01 = i1 + pd.Timestamp("2000-03-03")  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _02 = i1 * 3  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _03 = i1 * pd.Timedelta(seconds=20)  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
 
     i2 = pd.Interval(10, 20)
     check(assert_type(i2.length, int), int)
@@ -104,8 +104,8 @@ def test_interval_length() -> None:
     check(assert_type(i2 * 4.2, "pd.Interval[float]"), pd.Interval, float)
 
     if TYPE_CHECKING_INVALID_USAGE:
-        pd.Timestamp("2001-01-02") in i2  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        i2 + pd.Timedelta(seconds=20)  # type: ignore[type-var] # pyright: ignore[reportOperatorIssue]
+        _10 = pd.Timestamp("2001-01-02") in i2  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _11 = i2 + pd.Timedelta(seconds=20)  # type: ignore[type-var] # pyright: ignore[reportOperatorIssue]
     i3 = pd.Interval(13.2, 19.5)
     check(assert_type(i3.length, float), float)
     check(assert_type(i3.left, float), float)
@@ -117,8 +117,8 @@ def test_interval_length() -> None:
     check(assert_type(i3 + 3, "pd.Interval[float]"), pd.Interval, float)
     check(assert_type(i3 * 3, "pd.Interval[float]"), pd.Interval, float)
     if TYPE_CHECKING_INVALID_USAGE:
-        pd.Timestamp("2001-01-02") in i3  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        i3 + pd.Timedelta(seconds=20)  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _20 = pd.Timestamp("2001-01-02") in i3  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _21 = i3 + pd.Timedelta(seconds=20)  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
 
 
 def test_interval_array_contains():
diff --git a/tests/test_io.py b/tests/test_io.py
index 133839c6c..343252740 100644
--- a/tests/test_io.py
+++ b/tests/test_io.py
@@ -11,7 +11,6 @@
     TYPE_CHECKING,
     Any,
     Literal,
-    Union,
 )
 
 import numpy as np
@@ -300,7 +299,7 @@ def test_sas_bdat() -> None:
     path = pathlib.Path(CWD, "data", "airline.sas7bdat")
     check(assert_type(read_sas(path), DataFrame), DataFrame)
     with check(
-        assert_type(read_sas(path, iterator=True), Union[SAS7BDATReader, XportReader]),
+        assert_type(read_sas(path, iterator=True), SAS7BDATReader | XportReader),
         SAS7BDATReader,
     ):
         pass
@@ -310,7 +309,7 @@ def test_sas_bdat() -> None:
     ):
         pass
     with check(
-        assert_type(read_sas(path, chunksize=1), Union[SAS7BDATReader, XportReader]),
+        assert_type(read_sas(path, chunksize=1), SAS7BDATReader | XportReader),
         SAS7BDATReader,
     ):
         pass
@@ -325,7 +324,7 @@ def test_sas_xport() -> None:
     path = pathlib.Path(CWD, "data", "SSHSV1_A.xpt")
     check(assert_type(read_sas(path), DataFrame), DataFrame)
     with check(
-        assert_type(read_sas(path, iterator=True), Union[SAS7BDATReader, XportReader]),
+        assert_type(read_sas(path, iterator=True), SAS7BDATReader | XportReader),
         XportReader,
     ):
         pass
@@ -335,7 +334,7 @@ def test_sas_xport() -> None:
     ):
         pass
     with check(
-        assert_type(read_sas(path, chunksize=1), Union[SAS7BDATReader, XportReader]),
+        assert_type(read_sas(path, chunksize=1), SAS7BDATReader | XportReader),
         XportReader,
     ):
         pass
@@ -350,7 +349,7 @@ def test_sas_xport() -> None:
 def test_hdf():
     with ensure_clean() as path:
         check(assert_type(DF.to_hdf(path, key="df"), None), type(None))
-        check(assert_type(read_hdf(path), Union[DataFrame, Series]), DataFrame)
+        check(assert_type(read_hdf(path), DataFrame | Series), DataFrame)
 
 
 @pytest.mark.skipif(NUMPY20, reason="numpy 2.0 not compatible with Pytables")
@@ -363,35 +362,35 @@ def test_hdfstore() -> None:
         check(assert_type(store.keys(), list[str]), list)
         check(assert_type(store.info(), str), str)
         check(
-            assert_type(store.select("df", start=0, stop=1), Union[DataFrame, Series]),
+            assert_type(store.select("df", start=0, stop=1), DataFrame | Series),
             DataFrame,
         )
         check(
-            assert_type(store.select("df", where="index>=1"), Union[DataFrame, Series]),
+            assert_type(store.select("df", where="index>=1"), DataFrame | Series),
             DataFrame,
         )
         check(
             assert_type(
                 store.select("df", where=Term("index>=1")),
-                Union[DataFrame, Series],
+                DataFrame | Series,
             ),
             DataFrame,
         )
         check(
             assert_type(
                 store.select("df", where=[Term("index>=1")]),
-                Union[DataFrame, Series],
+                DataFrame | Series,
             ),
             DataFrame,
         )
-        check(assert_type(store.get("df"), Union[DataFrame, Series]), DataFrame)
+        check(assert_type(store.get("df"), DataFrame | Series), DataFrame)
         for key in store:
             check(assert_type(key, str), str)
         check(assert_type(store.close(), None), type(None))
 
         store = HDFStore(path, model="r")
         check(
-            assert_type(read_hdf(store, "df"), Union[DataFrame, Series]),
+            assert_type(read_hdf(store, "df"), DataFrame | Series),
             DataFrame,
         )
         store.close()
@@ -418,7 +417,7 @@ def test_hdf_context_manager() -> None:
         check(assert_type(DF.to_hdf(path, key="df", format="table"), None), type(None))
         with HDFStore(path, mode="r") as store:
             check(assert_type(store.is_open, bool), bool)
-            check(assert_type(store.get("df"), Union[DataFrame, Series]), DataFrame)
+            check(assert_type(store.get("df"), DataFrame | Series), DataFrame)
 
 
 @pytest.mark.skipif(NUMPY20, reason="numpy 2.0 not compatible with Pytables")
@@ -426,7 +425,7 @@ def test_hdf_series():
     s = DF["a"]
     with ensure_clean() as path:
         check(assert_type(s.to_hdf(path, key="s"), None), type(None))
-        check(assert_type(read_hdf(path, "s"), Union[DataFrame, Series]), Series)
+        check(assert_type(read_hdf(path, "s"), DataFrame | Series), Series)
 
 
 def test_spss():
@@ -987,7 +986,7 @@ def test_read_excel() -> None:
         check(
             assert_type(
                 pd.read_excel(path, sheet_name=[0, "Sheet1"]),
-                dict[Union[int, str], pd.DataFrame],
+                dict[int | str, pd.DataFrame],
             ),
             dict,
         )
@@ -1166,7 +1165,7 @@ def test_excel_writer():
         check(assert_type(read_excel(ef), DataFrame), DataFrame)
         check(assert_type(ef.parse(sheet_name=0), DataFrame), DataFrame)
         check(
-            assert_type(ef.parse(sheet_name=[0]), dict[Union[str, int], DataFrame]),
+            assert_type(ef.parse(sheet_name=[0]), dict[str | int, DataFrame]),
             dict,
         )
         check(assert_type(ef.close(), None), type(None))
@@ -1238,7 +1237,7 @@ def test_to_string():
 def test_read_sql():
     with ensure_clean() as path:
         con = sqlite3.connect(path)
-        check(assert_type(DF.to_sql("test", con=con), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=con), int | None), int)
         check(
             assert_type(read_sql("select * from test", con=con), DataFrame), DataFrame
         )
@@ -1251,7 +1250,7 @@ def test_read_sql_via_sqlalchemy_connection():
         engine = sqlalchemy.create_engine(db_uri)
 
         with engine.connect() as conn:
-            check(assert_type(DF.to_sql("test", con=conn), Union[int, None]), int)
+            check(assert_type(DF.to_sql("test", con=conn), int | None), int)
             check(
                 assert_type(read_sql("select * from test", con=conn), DataFrame),
                 DataFrame,
@@ -1264,7 +1263,7 @@ def test_read_sql_via_sqlalchemy_engine():
         db_uri = "sqlite:///" + path
         engine = sqlalchemy.create_engine(db_uri)
 
-        check(assert_type(DF.to_sql("test", con=engine), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=engine), int | None), int)
         check(
             assert_type(read_sql("select * from test", con=engine), DataFrame),
             DataFrame,
@@ -1277,7 +1276,7 @@ def test_read_sql_via_sqlalchemy_engine_with_params():
         db_uri = "sqlite:///" + path
         engine = sqlalchemy.create_engine(db_uri)
 
-        check(assert_type(DF.to_sql("test", con=engine), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=engine), int | None), int)
         check(
             assert_type(
                 read_sql(
@@ -1295,7 +1294,7 @@ def test_read_sql_via_sqlalchemy_engine_with_params():
 def test_read_sql_generator():
     with ensure_clean() as path:
         con = sqlite3.connect(path)
-        check(assert_type(DF.to_sql("test", con=con), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=con), int | None), int)
 
         check(
             assert_type(
@@ -1313,7 +1312,7 @@ def test_read_sql_table():
         # Could only run in pytest if SQLAlchemy was installed
         with ensure_clean() as path:
             con = sqlite3.connect(path)
-            assert_type(DF.to_sql("test", con=con), Union[int, None])
+            assert_type(DF.to_sql("test", con=con), int | None)
             assert_type(read_sql_table("test", con=con), DataFrame)
             assert_type(
                 read_sql_table("test", con=con, chunksize=1),
@@ -1325,7 +1324,7 @@ def test_read_sql_table():
 def test_read_sql_query():
     with ensure_clean() as path:
         con = sqlite3.connect(path)
-        check(assert_type(DF.to_sql("test", con=con), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=con), int | None), int)
         check(
             assert_type(
                 read_sql_query("select * from test", con=con, index_col="index"),
@@ -1339,7 +1338,7 @@ def test_read_sql_query():
 def test_read_sql_query_generator():
     with ensure_clean() as path:
         con = sqlite3.connect(path)
-        check(assert_type(DF.to_sql("test", con=con), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=con), int | None), int)
 
         check(
             assert_type(
@@ -1356,7 +1355,7 @@ def test_read_sql_query_via_sqlalchemy_engine_with_params():
         db_uri = "sqlite:///" + path
         engine = sqlalchemy.create_engine(db_uri)
 
-        check(assert_type(DF.to_sql("test", con=engine), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=engine), int | None), int)
         check(
             assert_type(
                 read_sql_query(
@@ -1454,7 +1453,7 @@ def test_sqlalchemy_text() -> None:
         engine = sqlalchemy.create_engine(db_uri)
         sql_select = sqlalchemy.text("select * from test")
         with engine.connect() as conn:
-            check(assert_type(DF.to_sql("test", con=conn), Union[int, None]), int)
+            check(assert_type(DF.to_sql("test", con=conn), int | None), int)
             check(
                 assert_type(read_sql(sql_select, con=conn), DataFrame),
                 DataFrame,
@@ -1469,7 +1468,7 @@ def test_read_sql_dtype() -> None:
             data=[[0, "10/11/12"], [1, "12/11/10"]],
             columns=["int_column", "date_column"],
         )
-        check(assert_type(df.to_sql("test_data", con=conn), Union[int, None]), int)
+        check(assert_type(df.to_sql("test_data", con=conn), int | None), int)
         check(
             assert_type(
                 pd.read_sql(
@@ -1492,7 +1491,7 @@ def test_read_sql_dtype() -> None:
             ),
             pd.DataFrame,
         )
-        check(assert_type(DF.to_sql("test", con=conn), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=conn), int | None), int)
 
         check(
             assert_type(
@@ -1507,7 +1506,7 @@ def test_read_sql_dtype() -> None:
 def test_read_sql_dtype_backend() -> None:
     with ensure_clean() as path:
         conn2 = sqlite3.connect(path)
-        check(assert_type(DF.to_sql("test", con=conn2), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=conn2), int | None), int)
         check(
             assert_type(
                 read_sql("select * from test", con=conn2, dtype_backend="pyarrow"),
@@ -1549,7 +1548,7 @@ def test_all_read_without_lxml_dtype_backend() -> None:
 
     with ensure_clean() as path:
         con = sqlite3.connect(path)
-        check(assert_type(DF.to_sql("test", con=con), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con=con), int | None), int)
         check(
             assert_type(
                 read_sql_query(
@@ -1600,7 +1599,7 @@ def test_all_read_without_lxml_dtype_backend() -> None:
         # Could only run in pytest if SQLAlchemy was installed
         with ensure_clean() as path:
             co1 = sqlite3.connect(path)
-            assert_type(DF.to_sql("test", con=co1), Union[int, None])
+            assert_type(DF.to_sql("test", con=co1), int | None)
             assert_type(
                 read_sql_table("test", con=co1, dtype_backend="numpy_nullable"),
                 DataFrame,
@@ -1628,7 +1627,7 @@ def test_read_sql_dict_str_value_dtype() -> None:
     # GH 676
     with ensure_clean() as path:
         con = sqlite3.connect(path)
-        check(assert_type(DF.to_sql("test", con), Union[int, None]), int)
+        check(assert_type(DF.to_sql("test", con), int | None), int)
         check(
             assert_type(
                 read_sql_query(
diff --git a/tests/test_pandas.py b/tests/test_pandas.py
index 8795b7fb7..f03705ed6 100644
--- a/tests/test_pandas.py
+++ b/tests/test_pandas.py
@@ -5,7 +5,6 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    Union,
 )
 
 import numpy as np
@@ -515,9 +514,9 @@ def test_isna() -> None:
     if not pd.isna(nullable1):
         check(assert_type(nullable1, str), str)
     if pd.isna(nullable1):
-        assert_type(nullable1, Union[NaTType, NAType, None])
+        assert_type(nullable1, NaTType | NAType | None)
     if not pd.notna(nullable1):
-        assert_type(nullable1, Union[NaTType, NAType, None])
+        assert_type(nullable1, NaTType | NAType | None)
 
     nullable2: int | None = random.choice([2, None])
     if pd.notna(nullable2):
@@ -535,9 +534,9 @@ def test_isna() -> None:
     if not pd.isna(nullable3):
         check(assert_type(nullable3, bool), bool)
     if pd.isna(nullable3):
-        assert_type(nullable3, Union[NAType, None])
+        assert_type(nullable3, NAType | None)
     if not pd.notna(nullable3):
-        assert_type(nullable3, Union[NAType, None])
+        assert_type(nullable3, NAType | None)
 
 
 # GH 55
@@ -557,23 +556,19 @@ def test_read_xml() -> None:
 def test_unique() -> None:
     # Taken from the docs
     check(
-        assert_type(
-            pd.unique(pd.Series([2, 1, 3, 3])), Union[np.ndarray, ExtensionArray]
-        ),
+        assert_type(pd.unique(pd.Series([2, 1, 3, 3])), np.ndarray | ExtensionArray),
         np.ndarray,
     )
 
     check(
-        assert_type(
-            pd.unique(pd.Series([2] + [1] * 5)), Union[np.ndarray, ExtensionArray]
-        ),
+        assert_type(pd.unique(pd.Series([2] + [1] * 5)), np.ndarray | ExtensionArray),
         np.ndarray,
     )
 
     check(
         assert_type(
             pd.unique(pd.Series([pd.Timestamp("20160101"), pd.Timestamp("20160101")])),
-            Union[np.ndarray, ExtensionArray],
+            np.ndarray | ExtensionArray,
         ),
         np.ndarray,
     )
@@ -588,7 +583,7 @@ def test_unique() -> None:
                     ]
                 )
             ),
-            Union[np.ndarray, ExtensionArray],
+            np.ndarray | ExtensionArray,
         ),
         pd.arrays.DatetimeArray,
     )
@@ -612,14 +607,14 @@ def test_unique() -> None:
     check(
         assert_type(
             pd.unique(pd.Series(pd.Categorical(list("baabc")))),
-            Union[np.ndarray, ExtensionArray],
+            np.ndarray | ExtensionArray,
         ),
         pd.Categorical,
     )
     check(
         assert_type(
             pd.unique(pd.Series(pd.Categorical(list("baabc"), categories=list("abc")))),
-            Union[np.ndarray, ExtensionArray],
+            np.ndarray | ExtensionArray,
         ),
         pd.Categorical,
     )
@@ -630,7 +625,7 @@ def test_unique() -> None:
                     pd.Categorical(list("baabc"), categories=list("abc"), ordered=True)
                 )
             ),
-            Union[np.ndarray, ExtensionArray],
+            np.ndarray | ExtensionArray,
         ),
         pd.Categorical,
     )
@@ -726,7 +721,7 @@ def test_eval():
     check(
         assert_type(
             pd.eval("double_age = df.age * 2", target=df),
-            Union[npt.NDArray, Scalar, pd.DataFrame, pd.Series, None],
+            npt.NDArray | Scalar | pd.DataFrame | pd.Series | None,
         ),
         pd.DataFrame,
     )
diff --git a/tests/test_plotting.py b/tests/test_plotting.py
index 82112dea7..c14938e1f 100644
--- a/tests/test_plotting.py
+++ b/tests/test_plotting.py
@@ -2,7 +2,6 @@
 import itertools
 from typing import (
     Any,
-    Union,
 )
 
 from matplotlib.axes import Axes
@@ -670,7 +669,7 @@ def test_grouped_dataframe_boxplot_single(close_figures):
         )
 
     # not a literal bool
-    check(assert_type(grouped.boxplot(subplots=bool(0.5)), Union[Axes, Series]), Series)
+    check(assert_type(grouped.boxplot(subplots=bool(0.5)), Axes | Series), Series)
 
 
 def test_grouped_dataframe_hist(close_figures):
diff --git a/tests/test_resampler.py b/tests/test_resampler.py
index 672f00e20..ad9f751d1 100644
--- a/tests/test_resampler.py
+++ b/tests/test_resampler.py
@@ -2,7 +2,6 @@
     Hashable,
     Iterator,
 )
-from typing import Union
 
 import numpy as np
 import pandas as pd
@@ -31,7 +30,7 @@
 DF = DataFrame({"col1": S, "col2": S})
 
 
-_AggRetType = Union[DataFrame, Series]
+_AggRetType = DataFrame | Series
 
 
 def test_props() -> None:
diff --git a/tests/test_string_accessors.py b/tests/test_string_accessors.py
index b501f681c..ac83e6e3a 100644
--- a/tests/test_string_accessors.py
+++ b/tests/test_string_accessors.py
@@ -280,7 +280,7 @@ def test_string_accessors_list_series():
     # rsplit doesn't accept compiled pattern
     # it doesn't raise at runtime but produces a nan
     if TYPE_CHECKING_INVALID_USAGE:
-        bad_rsplit_result = s.str.rsplit(
+        _bad_rsplit_result = s.str.rsplit(
             re.compile(r"a")  # type: ignore[call-overload] # pyright: ignore[reportArgumentType]
         )
 
@@ -300,7 +300,7 @@ def test_string_accessors_list_index():
     # rsplit doesn't accept compiled pattern
     # it doesn't raise at runtime but produces a nan
     if TYPE_CHECKING_INVALID_USAGE:
-        bad_rsplit_result = idx.str.rsplit(
+        _bad_rsplit_result = idx.str.rsplit(
             re.compile(r"a")  # type: ignore[call-overload] # pyright: ignore[reportArgumentType]
         )
 
diff --git a/tests/test_timefuncs.py b/tests/test_timefuncs.py
index 2fdf6a138..e126b8ada 100644
--- a/tests/test_timefuncs.py
+++ b/tests/test_timefuncs.py
@@ -2,7 +2,7 @@
 
 import datetime as dt
 from typing import (
-    Optional,
+    TypeAlias,
 )
 
 from dateutil.relativedelta import (
@@ -20,7 +20,6 @@
 from pandas.core.tools.datetimes import FulldatetimeDict
 import pytz
 from typing_extensions import (
-    TypeAlias,
     assert_never,
     assert_type,
 )
@@ -293,15 +292,15 @@ def test_fail_on_adding_two_timestamps() -> None:
     s1 = pd.Series(pd.to_datetime(["2022-05-01", "2022-06-01"]))
     s2 = pd.Series(pd.to_datetime(["2022-05-15", "2022-06-15"]))
     if TYPE_CHECKING_INVALID_USAGE:
-        ssum = s1 + s2  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _ssum = s1 + s2  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
         ts = pd.Timestamp("2022-06-30")
-        tsum = s1 + ts  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _tsum = s1 + ts  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
 
 
 def test_dtindex_tzinfo() -> None:
     # GH 71
     dti = pd.date_range("2000-1-1", periods=10)
-    check(assert_type(dti.tzinfo, Optional[dt.tzinfo]), type(None))
+    check(assert_type(dti.tzinfo, dt.tzinfo | None), type(None))
 
 
 def test_todatetime_fromnumpy() -> None:
@@ -376,8 +375,8 @@ def test_series_dt_accessors() -> None:
     check(assert_type(s0.dt.is_leap_year, "pd.Series[bool]"), pd.Series, np.bool_)
     check(assert_type(s0.dt.daysinmonth, "pd.Series[int]"), pd.Series, np.integer)
     check(assert_type(s0.dt.days_in_month, "pd.Series[int]"), pd.Series, np.integer)
-    check(assert_type(s0.dt.tz, Optional[dt.tzinfo]), type(None))
-    check(assert_type(s0.dt.freq, Optional[str]), str)
+    check(assert_type(s0.dt.tz, dt.tzinfo | None), type(None))
+    check(assert_type(s0.dt.freq, str | None), str)
     check(assert_type(s0.dt.isocalendar(), pd.DataFrame), pd.DataFrame)
     check(
         assert_type(s0.dt.to_period("D"), "pd.Series[pd.Period]"), pd.Series, pd.Period
@@ -448,8 +447,8 @@ def test_series_dt_accessors() -> None:
         pd.Series,
         pd.Timestamp,
     )
-    check(assert_type(s0.dt.tz, Optional[dt.tzinfo]), type(None))
-    check(assert_type(s0_local.dt.tz, Optional[dt.tzinfo]), dt.tzinfo)
+    check(assert_type(s0.dt.tz, dt.tzinfo | None), type(None))
+    check(assert_type(s0_local.dt.tz, dt.tzinfo | None), dt.tzinfo)
     check(
         assert_type(s0.dt.normalize(), "pd.Series[pd.Timestamp]"),
         pd.Series,
@@ -676,8 +675,8 @@ def test_datetimeindex_accessors() -> None:
     check(assert_type(i0.is_leap_year, np_1darray[np.bool]), np_1darray[np.bool])
     check(assert_type(i0.daysinmonth, "pd.Index[int]"), pd.Index, np.int32)
     check(assert_type(i0.days_in_month, "pd.Index[int]"), pd.Index, np.int32)
-    check(assert_type(i0.tz, Optional[dt.tzinfo]), type(None))
-    check(assert_type(i0.freq, Optional[BaseOffset]), BaseOffset)
+    check(assert_type(i0.tz, dt.tzinfo | None), type(None))
+    check(assert_type(i0.freq, BaseOffset | None), BaseOffset)
     check(assert_type(i0.isocalendar(), pd.DataFrame), pd.DataFrame)
     check(assert_type(i0.to_period("D"), pd.PeriodIndex), pd.PeriodIndex, pd.Period)
     check(
@@ -698,7 +697,7 @@ def test_datetimeindex_accessors() -> None:
         assert_type(ilocal.tz_convert(pytz.timezone("US/Pacific")), pd.DatetimeIndex),
         pd.DatetimeIndex,
     )
-    check(assert_type(ilocal.tz, Optional[dt.tzinfo]), dt.tzinfo)
+    check(assert_type(ilocal.tz, dt.tzinfo | None), dt.tzinfo)
     check(assert_type(i0.normalize(), pd.DatetimeIndex), pd.DatetimeIndex, pd.Timestamp)
     check(assert_type(i0.strftime("%Y"), pd.Index), pd.Index, str)
     check(assert_type(i0.round("D"), pd.DatetimeIndex), pd.DatetimeIndex, pd.Timestamp)
@@ -763,7 +762,7 @@ def test_periodindex_accessors() -> None:
     check(assert_type(i0.quarter, "pd.Index[int]"), pd.Index, np.integer)
     check(assert_type(i0.daysinmonth, "pd.Index[int]"), pd.Index, np.integer)
     check(assert_type(i0.days_in_month, "pd.Index[int]"), pd.Index, np.integer)
-    check(assert_type(i0.freq, Optional[BaseOffset]), BaseOffset)
+    check(assert_type(i0.freq, BaseOffset | None), BaseOffset)
     check(assert_type(i0.strftime("%Y"), pd.Index), pd.Index, str)
     check(assert_type(i0.asfreq("D"), pd.PeriodIndex), pd.PeriodIndex, pd.Period)
     check(assert_type(i0.end_time, pd.DatetimeIndex), pd.DatetimeIndex, pd.Timestamp)
@@ -1706,9 +1705,9 @@ def test_timedelta64_and_arithmatic_operator() -> None:
     td = np.timedelta64(1, "D")
     check(assert_type((s3 / td), "pd.Series[float]"), pd.Series, float)
     if TYPE_CHECKING_INVALID_USAGE:
-        r1 = s1 * td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        r2 = s1 / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
-        r3 = s3 * td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _1 = s1 * td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _2 = s1 / td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
+        _3 = s3 * td  # type: ignore[operator] # pyright: ignore[reportOperatorIssue]
 
 
 def test_timedeltaseries_add_timestampseries() -> None:
@@ -1944,7 +1943,7 @@ def test_timestamp_to_list_add() -> None:
     check(assert_type(tslist, list[pd.Timestamp]), list, pd.Timestamp)
     sseries = pd.Series(tslist)
     with pytest_warns_bounded(Pandas4Warning, "'d' is deprecated", lower="2.3.99"):
-        sseries + pd.Timedelta(1, "d")
+        _0 = sseries + pd.Timedelta(1, "d")
 
     check(
         assert_type(sseries + pd.Timedelta(1, "D"), "pd.Series[pd.Timestamp]"),