Sphinx 7.4.6__py3-none-any.whl → 8.0.0__py3-none-any.whl

sphinx/util/osutil.py

@@ -11,13 +11,12 @@ import sys
 import unicodedata
 from io import StringIO
 from os import path
+from pathlib import Path
 from typing import TYPE_CHECKING
 
-from sphinx.deprecation import _deprecation_warning
+from sphinx.locale import __
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
-    from pathlib import Path
     from types import TracebackType
     from typing import Any
 
@@ -51,7 +50,7 @@ def relative_uri(base: str, to: str) -> str:
     b2 = base.split('#')[0].split(SEP)
     t2 = to.split('#')[0].split(SEP)
     # remove common segments (except the last segment)
-    for x, y in zip(b2[:-1], t2[:-1]):
+    for x, y in zip(b2[:-1], t2[:-1], strict=False):
         if x != y:
             break
         b2.pop(0)
@@ -72,40 +71,71 @@ def ensuredir(file: str | os.PathLike[str]) -> None:
     os.makedirs(file, exist_ok=True)
 
 
-def mtimes_of_files(dirnames: list[str], suffix: str) -> Iterator[float]:
-    for dirname in dirnames:
-        for root, _dirs, files in os.walk(dirname):
-            for sfile in files:
-                if sfile.endswith(suffix):
-                    with contextlib.suppress(OSError):
-                        yield path.getmtime(path.join(root, sfile))
+def _last_modified_time(source: str | os.PathLike[str], /) -> int:
+    """Return the last modified time of ``filename``.
 
+    The time is returned as integer microseconds.
+    The lowest common denominator of modern file-systems seems to be
+    microsecond-level precision.
 
-def copytimes(source: str | os.PathLike[str], dest: str | os.PathLike[str]) -> None:
+    We prefer to err on the side of re-rendering a file,
+    so we round up to the nearest microsecond.
+    """
+    st = source.stat() if isinstance(source, os.DirEntry) else os.stat(source)
+    # upside-down floor division to get the ceiling
+    return -(st.st_mtime_ns // -1_000)
+
+
+def _copy_times(source: str | os.PathLike[str], dest: str | os.PathLike[str]) -> None:
     """Copy a file's modification times."""
-    st = os.stat(source)
-    if hasattr(os, 'utime'):
-        os.utime(dest, (st.st_atime, st.st_mtime))
+    st = source.stat() if isinstance(source, os.DirEntry) else os.stat(source)
+    os.utime(dest, ns=(st.st_atime_ns, st.st_mtime_ns))
 
 
-def copyfile(source: str | os.PathLike[str], dest: str | os.PathLike[str]) -> None:
+def copyfile(
+    source: str | os.PathLike[str],
+    dest: str | os.PathLike[str],
+    *,
+    force: bool = False,
+) -> None:
     """Copy a file and its modification times, if possible.
 
     :param source: An existing source to copy.
     :param dest: The destination path.
+    :param bool force: Overwrite the destination file even if it exists.
     :raise FileNotFoundError: The *source* does not exist.
 
     .. note:: :func:`copyfile` is a no-op if *source* and *dest* are identical.
     """
-    if not path.exists(source):
-        msg = f'{os.fsdecode(source)} does not exist'
+    # coerce to Path objects
+    source = Path(source)
+    dest = Path(dest)
+    if not source.exists():
+        msg = f'{source} does not exist'
         raise FileNotFoundError(msg)
 
-    if not path.exists(dest) or not filecmp.cmp(source, dest):
+    if (
+        not (dest_exists := dest.exists()) or
+        # comparison must be done using shallow=False since
+        # two different files might have the same size
+        not filecmp.cmp(source, dest, shallow=False)
+    ):
+        if not force and dest_exists:
+            # sphinx.util.logging imports sphinx.util.osutil,
+            # so use a local import to avoid circular imports
+            from sphinx.util import logging
+            logger = logging.getLogger(__name__)
+
+            msg = __('Aborted attempted copy from %s to %s '
+                     '(the destination path has existing data).')
+            logger.warning(msg, source, dest,
+                           type='misc', subtype='copy_overwrite')
+            return
+
         shutil.copyfile(source, dest)
         with contextlib.suppress(OSError):
             # don't do full copystat because the source may be read-only
-            copytimes(source, dest)
+            _copy_times(source, dest)
 
 
 _no_fn_re = re.compile(r'[^a-zA-Z0-9_-]')
@@ -161,12 +191,8 @@ class _chdir:
         os.chdir(self._dirs.pop())
 
 
-@contextlib.contextmanager
-def cd(target_dir: str) -> Iterator[None]:
-    if sys.version_info[:2] >= (3, 11):
-        _deprecation_warning(__name__, 'cd', 'contextlib.chdir', remove=(8, 0))
-    with _chdir(target_dir):
-        yield
+if sys.version_info[:2] < (3, 11):
+    cd = _chdir
 
 
 class FileAvoidWrite:

sphinx/util/parallel.py

@@ -6,7 +6,7 @@ import os
 import time
 import traceback
 from math import sqrt
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 try:
     import multiprocessing
@@ -18,7 +18,7 @@ from sphinx.errors import SphinxParallelError
 from sphinx.util import logging
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Callable, Sequence
 
 logger = logging.getLogger(__name__)
 

sphinx/util/requests.py

@@ -19,7 +19,7 @@ def _get_tls_cacert(url: str, certs: str | dict[str, str] | None) -> str | bool:
     """Get additional CA cert for a specific URL."""
     if not certs:
         return True
-    elif isinstance(certs, (str, tuple)):
+    elif isinstance(certs, str | tuple):
         return certs
     else:
         hostname = urlsplit(url).netloc

sphinx/util/template.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import os
 from functools import partial
 from os import path
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from jinja2 import TemplateNotFound
 from jinja2.loaders import BaseLoader
@@ -17,7 +17,7 @@ from sphinx.locale import get_translator
 from sphinx.util import rst, texescape
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Callable, Sequence
 
     from jinja2.environment import Environment
 
@@ -38,7 +38,7 @@ class BaseRenderer:
 
 class FileRenderer(BaseRenderer):
     def __init__(self, search_path: Sequence[str | os.PathLike[str]]) -> None:
-        if isinstance(search_path, (str, os.PathLike)):
+        if isinstance(search_path, str | os.PathLike):
             search_path = [search_path]
         else:
             # filter "None" paths

sphinx/util/typing.py

@@ -2,18 +2,19 @@
 
 from __future__ import annotations
 
+import dataclasses
 import sys
 import types
 import typing
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from contextvars import Context, ContextVar, Token
 from struct import Struct
 from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
-    Callable,
     ForwardRef,
+    NewType,
     TypedDict,
     TypeVar,
     Union,
@@ -24,9 +25,9 @@ from docutils.parsers.rst.states import Inliner
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
-    from typing import Final, Literal, Protocol
+    from typing import Final, Literal, Protocol, TypeAlias
 
-    from typing_extensions import TypeAlias, TypeIs
+    from typing_extensions import TypeIs
 
     from sphinx.application import Sphinx
 
@@ -40,10 +41,6 @@ if TYPE_CHECKING:
         'smart',
     ]
 
-if sys.version_info >= (3, 10):
-    from types import UnionType
-else:
-    UnionType = None
 
 # classes that have an incorrect .__module__ attribute
 _INVALID_BUILTIN_CLASSES: Final[Mapping[object, str]] = {
@@ -84,13 +81,10 @@ def is_invalid_builtin_class(obj: Any) -> bool:
 
 
 # Text like nodes which are initialized with text and rawsource
-TextlikeNode = Union[nodes.Text, nodes.TextElement]
-
-# type of None
-NoneType = type(None)
+TextlikeNode: TypeAlias = nodes.Text | nodes.TextElement
 
 # path matcher
-PathMatcher = Callable[[str], bool]
+PathMatcher: TypeAlias = Callable[[str], bool]
 
 # common role functions
 if TYPE_CHECKING:
@@ -108,25 +102,25 @@ if TYPE_CHECKING:
         ) -> tuple[list[nodes.Node], list[nodes.system_message]]:
             ...
 else:
-    RoleFunction = Callable[
+    RoleFunction: TypeAlias = Callable[
         [str, str, str, int, Inliner, dict[str, Any], Sequence[str]],
         tuple[list[nodes.Node], list[nodes.system_message]],
     ]
 
 # A option spec for directive
-OptionSpec = dict[str, Callable[[str], Any]]
+OptionSpec: TypeAlias = dict[str, Callable[[str], Any]]
 
 # title getter functions for enumerable nodes (see sphinx.domains.std)
-TitleGetter = Callable[[nodes.Node], str]
+TitleGetter: TypeAlias = Callable[[nodes.Node], str]
 
 # inventory data on memory
-InventoryItem = tuple[
+InventoryItem: TypeAlias = tuple[
     str,  # project name
     str,  # project version
     str,  # URL
     str,  # display name
 ]
-Inventory = dict[str, dict[str, InventoryItem]]
+Inventory: TypeAlias = dict[str, dict[str, InventoryItem]]
 
 
 class ExtensionMetadata(TypedDict, total=False):
@@ -150,13 +144,14 @@ class ExtensionMetadata(TypedDict, total=False):
 
 
 if TYPE_CHECKING:
-    _ExtensionSetupFunc = Callable[[Sphinx], ExtensionMetadata]
+    _ExtensionSetupFunc: TypeAlias = Callable[[Sphinx], ExtensionMetadata]
 
 
 def get_type_hints(
     obj: Any,
     globalns: dict[str, Any] | None = None,
     localns: dict[str, Any] | None = None,
+    include_extras: bool = False,
 ) -> dict[str, Any]:
     """Return a dictionary containing type hints for a function, method, module or class
     object.
@@ -167,7 +162,7 @@ def get_type_hints(
     from sphinx.util.inspect import safe_getattr  # lazy loading
 
     try:
-        return typing.get_type_hints(obj, globalns, localns)
+        return typing.get_type_hints(obj, globalns, localns, include_extras=include_extras)
     except NameError:
         # Failed to evaluate ForwardRef (maybe TYPE_CHECKING)
         return safe_getattr(obj, '__annotations__', {})
@@ -202,24 +197,14 @@ def _is_unpack_form(obj: Any) -> bool:
         # that typing_extensions.Unpack should not be used in that case
         return typing.get_origin(obj) is Unpack
 
-    # 3.9 and 3.10 require typing_extensions.Unpack
+    # Python 3.10 requires typing_extensions.Unpack
     origin = typing.get_origin(obj)
     return (
         getattr(origin, '__module__', None) == 'typing_extensions'
-        and _typing_internal_name(origin) == 'Unpack'
+        and origin.__name__ == 'Unpack'
     )
 
 
-def _typing_internal_name(obj: Any) -> str | None:
-    if sys.version_info[:2] >= (3, 10):
-        try:
-            return obj.__name__
-        except AttributeError:
-            # e.g. ParamSpecArgs, ParamSpecKwargs
-            return ''
-    return getattr(obj, '_name', None)
-
-
 def restify(cls: Any, mode: _RestifyMode = 'fully-qualified-except-typing') -> str:
     """Convert a type-like object to a reST reference.
 
@@ -232,7 +217,7 @@ def restify(cls: Any, mode: _RestifyMode = 'fully-qualified-except-typing') -> s
                      Show the name of the annotation.
     """
     from sphinx.ext.autodoc.mock import ismock, ismockmodule  # lazy loading
-    from sphinx.util import inspect  # lazy loading
+    from sphinx.util.inspect import isgenericalias, object_description  # lazy loading
 
     valid_modes = {'fully-qualified-except-typing', 'smart'}
     if mode not in valid_modes:
@@ -241,7 +226,7 @@ def restify(cls: Any, mode: _RestifyMode = 'fully-qualified-except-typing') -> s
         raise ValueError(msg)
 
     # things that are not types
-    if cls is None or cls == NoneType:
+    if cls is None or cls == types.NoneType:
         return ':py:obj:`None`'
     if cls is Ellipsis:
         return '...'
@@ -267,18 +252,28 @@ def restify(cls: Any, mode: _RestifyMode = 'fully-qualified-except-typing') -> s
             return f':py:class:`{module_prefix}{_INVALID_BUILTIN_CLASSES[cls]}`'
         elif _is_annotated_form(cls):
             args = restify(cls.__args__[0], mode)
-            meta = ', '.join(map(repr, cls.__metadata__))
+            meta_args = []
+            for m in cls.__metadata__:
+                if isinstance(m, type):
+                    meta_args.append(restify(m, mode))
+                elif dataclasses.is_dataclass(m):
+                    # use restify for the repr of field values rather than repr
+                    d_fields = ', '.join([
+                        fr"{f.name}=\ {restify(getattr(m, f.name), mode)}"
+                        for f in dataclasses.fields(m) if f.repr
+                    ])
+                    meta_args.append(fr'{restify(type(m), mode)}\ ({d_fields})')
+                else:
+                    meta_args.append(repr(m))
+            meta = ', '.join(meta_args)
             if sys.version_info[:2] <= (3, 11):
                 # Hardcoded to fix errors on Python 3.11 and earlier.
                 return fr':py:class:`~typing.Annotated`\ [{args}, {meta}]'
             return (f':py:class:`{module_prefix}{cls.__module__}.{cls.__name__}`'
                     fr'\ [{args}, {meta}]')
-        elif inspect.isNewType(cls):
-            if sys.version_info[:2] >= (3, 10):
-                # newtypes have correct module info since Python 3.10+
-                return f':py:class:`{module_prefix}{cls.__module__}.{cls.__name__}`'
-            return f':py:class:`{cls.__name__}`'
-        elif UnionType and isinstance(cls, UnionType):
+        elif isinstance(cls, NewType):
+            return f':py:class:`{module_prefix}{cls.__module__}.{cls.__name__}`'  # type: ignore[attr-defined]
+        elif isinstance(cls, types.UnionType):
             # Union types (PEP 585) retain their definition order when they
             # are printed natively and ``None``-like types are kept as is.
             return ' | '.join(restify(a, mode) for a in cls.__args__)
@@ -290,23 +285,18 @@ def restify(cls: Any, mode: _RestifyMode = 'fully-qualified-except-typing') -> s
                 concatenated_args = ', '.join(restify(arg, mode) for arg in cls.__args__)
                 return fr':py:class:`{cls.__name__}`\ [{concatenated_args}]'
             return f':py:class:`{cls.__name__}`'
-        elif (inspect.isgenericalias(cls)
+        elif (isgenericalias(cls)
               and cls_module_is_typing
               and cls.__origin__ is Union):
             # *cls* is defined in ``typing``, and thus ``__args__`` must exist
             return ' | '.join(restify(a, mode) for a in cls.__args__)
-        elif inspect.isgenericalias(cls):
-            # A generic alias always has an __origin__, but it is difficult to
-            # use a type guard on inspect.isgenericalias()
-            # (ideally, we would use ``TypeIs`` introduced in Python 3.13).
-            cls_name = _typing_internal_name(cls)
-
+        elif isgenericalias(cls):
             if isinstance(cls.__origin__, typing._SpecialForm):
                 # ClassVar; Concatenate; Final; Literal; Unpack; TypeGuard; TypeIs
                 # Required/NotRequired
                 text = restify(cls.__origin__, mode)
-            elif cls_name:
-                text = f':py:class:`{module_prefix}{cls.__module__}.{cls_name}`'
+            elif cls.__name__:
+                text = f':py:class:`{module_prefix}{cls.__module__}.{cls.__name__}`'
             else:
                 text = restify(cls.__origin__, mode)
 
@@ -319,14 +309,14 @@ def restify(cls: Any, mode: _RestifyMode = 'fully-qualified-except-typing') -> s
 
             # Callable has special formatting
             if (
-                (cls_module_is_typing and _typing_internal_name(cls) == 'Callable')
+                (cls_module_is_typing and cls.__name__ == 'Callable')
                 or (cls.__module__ == 'collections.abc' and cls.__name__ == 'Callable')
             ):
                 args = ', '.join(restify(a, mode) for a in __args__[:-1])
                 returns = restify(__args__[-1], mode)
                 return fr'{text}\ [[{args}], {returns}]'
 
-            if cls_module_is_typing and _typing_internal_name(cls.__origin__) == 'Literal':
+            if cls_module_is_typing and cls.__origin__.__name__ == 'Literal':
                 args = ', '.join(_format_literal_arg_restify(a, mode=mode)
                                  for a in cls.__args__)
                 return fr'{text}\ [{args}]'
@@ -335,8 +325,7 @@ def restify(cls: Any, mode: _RestifyMode = 'fully-qualified-except-typing') -> s
             args = ', '.join(restify(a, mode) for a in __args__)
             return fr'{text}\ [{args}]'
         elif isinstance(cls, typing._SpecialForm):
-            cls_name = _typing_internal_name(cls)
-            return f':py:obj:`~{cls.__module__}.{cls_name}`'
+            return f':py:obj:`~{cls.__module__}.{cls.__name__}`'  # type: ignore[attr-defined]
         elif sys.version_info[:2] >= (3, 11) and cls is typing.Any:
             # handle bpo-46998
             return f':py:obj:`~{cls.__module__}.{cls.__name__}`'
@@ -348,7 +337,7 @@ def restify(cls: Any, mode: _RestifyMode = 'fully-qualified-except-typing') -> s
             # not a class (ex. TypeVar) but should have a __name__
             return f':py:obj:`{module_prefix}{cls.__module__}.{cls.__name__}`'
     except (AttributeError, TypeError):
-        return inspect.object_description(cls)
+        return object_description(cls)
 
 
 def _format_literal_arg_restify(arg: Any, /, *, mode: str) -> str:
@@ -383,7 +372,6 @@ def stringify_annotation(
                      Show the module name and qualified name of the annotation.
     """
     from sphinx.ext.autodoc.mock import ismock, ismockmodule  # lazy loading
-    from sphinx.util.inspect import isNewType  # lazy loading
 
     valid_modes = {'fully-qualified-except-typing', 'fully-qualified', 'smart'}
     if mode not in valid_modes:
@@ -392,7 +380,7 @@ def stringify_annotation(
         raise ValueError(msg)
 
     # things that are not types
-    if annotation is None or annotation == NoneType:
+    if annotation is None or annotation == types.NoneType:
         return 'None'
     if annotation is Ellipsis:
         return '...'
@@ -418,18 +406,15 @@ def stringify_annotation(
         if annotation_module_is_typing and mode in {'fully-qualified-except-typing', 'smart'}:
             return annotation_name
         return module_prefix + f'{annotation_module}.{annotation_name}'
-    elif isNewType(annotation):
-        if sys.version_info[:2] >= (3, 10):
-            # newtypes have correct module info since Python 3.10+
-            return module_prefix + f'{annotation_module}.{annotation_name}'
-        return annotation_name
+    elif isinstance(annotation, NewType):
+        return module_prefix + f'{annotation_module}.{annotation_name}'
     elif ismockmodule(annotation):
         return module_prefix + annotation_name
     elif ismock(annotation):
         return module_prefix + f'{annotation_module}.{annotation_name}'
     elif is_invalid_builtin_class(annotation):
         return module_prefix + _INVALID_BUILTIN_CLASSES[annotation]
-    elif _is_annotated_form(annotation):  # for py39+
+    elif _is_annotated_form(annotation):  # for py310+
         pass
     elif annotation_module == 'builtins' and annotation_qualname:
         args = getattr(annotation, '__args__', None)
@@ -463,8 +448,8 @@ def stringify_annotation(
             # handle ForwardRefs
             qualname = annotation_forward_arg
         else:
-            if internal_name := _typing_internal_name(annotation):
-                qualname = internal_name
+            if annotation_name:
+                qualname = annotation_name
             elif annotation_qualname:
                 qualname = annotation_qualname
             else:
@@ -478,7 +463,7 @@ def stringify_annotation(
     elif hasattr(annotation, '__origin__'):
         # instantiated generic provided by a user
         qualname = stringify_annotation(annotation.__origin__, mode)
-    elif UnionType and isinstance(annotation, UnionType):  # types.UnionType (for py3.10+)
+    elif isinstance(annotation, types.UnionType):
         qualname = 'types.UnionType'
     else:
         # we weren't able to extract the base type, appending arguments would
@@ -488,7 +473,7 @@ def stringify_annotation(
     # Process the generic arguments (if any).
     # They must be a list or a tuple, otherwise they are considered 'broken'.
     annotation_args = getattr(annotation, '__args__', ())
-    if annotation_args and isinstance(annotation_args, (list, tuple)):
+    if annotation_args and isinstance(annotation_args, list | tuple):
         if (
             qualname in {'Union', 'types.UnionType'}
             and all(getattr(a, '__origin__', ...) is typing.Literal for a in annotation_args)
@@ -508,9 +493,22 @@ def stringify_annotation(
             args = ', '.join(_format_literal_arg_stringify(a, mode=mode)
                              for a in annotation_args)
             return f'{module_prefix}Literal[{args}]'
-        elif _is_annotated_form(annotation):  # for py39+
+        elif _is_annotated_form(annotation):  # for py310+
             args = stringify_annotation(annotation_args[0], mode)
-            meta = ', '.join(map(repr, annotation.__metadata__))
+            meta_args = []
+            for m in annotation.__metadata__:
+                if isinstance(m, type):
+                    meta_args.append(stringify_annotation(m, mode))
+                elif dataclasses.is_dataclass(m):
+                    # use stringify_annotation for the repr of field values rather than repr
+                    d_fields = ', '.join([
+                        f"{f.name}={stringify_annotation(getattr(m, f.name), mode)}"
+                        for f in dataclasses.fields(m) if f.repr
+                    ])
+                    meta_args.append(f'{stringify_annotation(type(m), mode)}({d_fields})')
+                else:
+                    meta_args.append(repr(m))
+            meta = ', '.join(meta_args)
             if sys.version_info[:2] <= (3, 11):
                 if mode == 'fully-qualified-except-typing':
                     return f'Annotated[{args}, {meta}]'
@@ -542,7 +540,6 @@ def _format_literal_arg_stringify(arg: Any, /, *, mode: str) -> str:
 
 # deprecated name -> (object to return, canonical path or empty string, removal version)
 _DEPRECATED_OBJECTS: dict[str, tuple[Any, str, tuple[int, int]]] = {
-    'stringify': (stringify_annotation, 'sphinx.util.typing.stringify_annotation', (8, 0)),
 }
 
 

sphinx/writers/html.py

@@ -20,7 +20,7 @@ HTMLTranslator = HTML5Translator
 # https://www.arnebrodowski.de/blog/write-your-own-restructuredtext-writer.html
 
 
-class HTMLWriter(Writer):
+class HTMLWriter(Writer):  # type: ignore[misc]
 
     # override embed-stylesheet default value to False.
     settings_default_overrides = {"embed_stylesheet": False}

sphinx/writers/html5.py

@@ -43,7 +43,7 @@ def multiply_length(length: str, scale: int) -> str:
     return f"{int(result)}{unit}"
 
 
-class HTML5Translator(SphinxTranslator, BaseTranslator):
+class HTML5Translator(SphinxTranslator, BaseTranslator):  # type: ignore[misc]
     """
     Our custom HTML translator.
     """

sphinx/writers/latex.py

@@ -66,7 +66,7 @@ class UnsupportedError(SphinxError):
     category = 'Markup is unsupported in LaTeX'
 
 
-class LaTeXWriter(writers.Writer):
+class LaTeXWriter(writers.Writer):  # type: ignore[misc]
 
     supported = ('sphinxlatex',)
 
@@ -1369,7 +1369,7 @@ class LaTeXTranslator(SphinxTranslator):
                 not isinstance(node.parent[index - 1], nodes.compound)):
             # insert blank line, if the paragraph follows a non-paragraph node in a compound
             self.body.append(r'\noindent' + CR)
-        elif index == 1 and isinstance(node.parent, (nodes.footnote, footnotetext)):
+        elif index == 1 and isinstance(node.parent, nodes.footnote | footnotetext):
             # don't insert blank line, if the paragraph is second child of a footnote
             # (first one is label node)
             pass
@@ -2081,7 +2081,7 @@ class LaTeXTranslator(SphinxTranslator):
         done = 0
         if len(node.children) == 1:
             child = node.children[0]
-            if isinstance(child, (nodes.bullet_list, nodes.enumerated_list)):
+            if isinstance(child, nodes.bullet_list | nodes.enumerated_list):
                 done = 1
         if not done:
             self.body.append(r'\begin{quote}' + CR)
@@ -2092,7 +2092,7 @@ class LaTeXTranslator(SphinxTranslator):
         done = 0
         if len(node.children) == 1:
             child = node.children[0]
-            if isinstance(child, (nodes.bullet_list, nodes.enumerated_list)):
+            if isinstance(child, nodes.bullet_list | nodes.enumerated_list):
                 done = 1
         if not done:
             self.body.append(r'\end{quote}' + CR)

sphinx/writers/manpage.py

@@ -24,7 +24,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class ManualPageWriter(Writer):
+class ManualPageWriter(Writer):  # type: ignore[misc]
     def __init__(self, builder: Builder) -> None:
         super().__init__()
         self.builder = builder
@@ -70,7 +70,7 @@ class NestedInlineTransform:
                     node.parent.remove(node)
 
 
-class ManualPageTranslator(SphinxTranslator, BaseTranslator):
+class ManualPageTranslator(SphinxTranslator, BaseTranslator):  # type: ignore[misc]
     """
     Custom man page translator.
     """

sphinx/writers/texinfo.py

@@ -105,7 +105,7 @@ def smart_capwords(s: str, sep: str | None = None) -> str:
     return (sep or ' ').join(words)
 
 
-class TexinfoWriter(writers.Writer):
+class TexinfoWriter(writers.Writer):  # type: ignore[misc]
     """Texinfo writer for generating Texinfo documents."""
 
     supported = ('texinfo', 'texi')
@@ -297,7 +297,7 @@ class TexinfoTranslator(SphinxTranslator):
         # try to find a suitable "Top" node
         title = self.document.next_node(nodes.title)
         top = title.parent if title else self.document
-        if not isinstance(top, (nodes.document, nodes.section)):
+        if not isinstance(top, nodes.document | nodes.section):
             top = self.document
         if top is not self.document:
             entries = node_menus[top['node_name']]
@@ -625,7 +625,7 @@ class TexinfoTranslator(SphinxTranslator):
         parent = node.parent
         if isinstance(parent, nodes.table):
             return
-        if isinstance(parent, (nodes.Admonition, nodes.sidebar, nodes.topic)):
+        if isinstance(parent, nodes.Admonition | nodes.sidebar | nodes.topic):
             raise nodes.SkipNode
         if not isinstance(parent, nodes.section):
             logger.warning(__('encountered title node not in section, topic, table, '
@@ -694,7 +694,7 @@ class TexinfoTranslator(SphinxTranslator):
     def visit_reference(self, node: Element) -> None:
         # an xref's target is displayed in Info so we ignore a few
         # cases for the sake of appearance
-        if isinstance(node.parent, (nodes.title, addnodes.desc_type)):
+        if isinstance(node.parent, nodes.title | addnodes.desc_type):
             return
         if len(node) != 0 and isinstance(node[0], nodes.image):
             return
@@ -987,7 +987,7 @@ class TexinfoTranslator(SphinxTranslator):
             self.add_anchor(id, node)
         # anchors and indexes need to go in front
         for n in node[::]:
-            if isinstance(n, (addnodes.index, nodes.target)):
+            if isinstance(n, addnodes.index | nodes.target):
                 n.walkabout(self)
                 node.remove(n)
         self.body.append('\n%s ' % self.at_item_x)