Sphinx 7.2.5__py3-none-any.whl → 7.3.0__py3-none-any.whl

sphinx/util/template.py

@@ -26,7 +26,8 @@ class BaseRenderer:
     def __init__(self, loader: BaseLoader | None = None) -> None:
         self.env = SandboxedEnvironment(loader=loader, extensions=['jinja2.ext.i18n'])
         self.env.filters['repr'] = repr
-        self.env.install_gettext_translations(get_translator())
+        # ``install_gettext_translations`` is injected by the ``jinja2.ext.i18n`` extension
+        self.env.install_gettext_translations(get_translator())  # type: ignore[attr-defined]
 
     def render(self, template_name: str, context: dict[str, Any]) -> str:
         return self.env.get_template(template_name).render(context)
@@ -47,7 +48,9 @@ class FileRenderer(BaseRenderer):
         super().__init__(loader)
 
     @classmethod
-    def render_from_file(cls, filename: str, context: dict[str, Any]) -> str:
+    def render_from_file(
+        cls: type[FileRenderer], filename: str, context: dict[str, Any],
+    ) -> str:
         dirname = os.path.dirname(filename)
         basename = os.path.basename(filename)
         return cls(dirname).render(basename, context)
@@ -60,7 +63,9 @@ class SphinxRenderer(FileRenderer):
         super().__init__(template_path)
 
     @classmethod
-    def render_from_file(cls, filename: str, context: dict[str, Any]) -> str:
+    def render_from_file(
+        cls: type[FileRenderer], filename: str, context: dict[str, Any],
+    ) -> str:
         return FileRenderer.render_from_file(filename, context)
 
 

sphinx/util/typing.py

@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import sys
+import types
 import typing
 from collections.abc import Sequence
+from contextvars import Context, ContextVar, Token
 from struct import Struct
-from types import TracebackType
-from typing import TYPE_CHECKING, Any, Callable, ForwardRef, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, ForwardRef, TypedDict, TypeVar, Union
 
 from docutils import nodes
 from docutils.parsers.rst.states import Inliner
@@ -15,22 +16,47 @@ from docutils.parsers.rst.states import Inliner
 if TYPE_CHECKING:
     import enum
 
-try:
-    from types import UnionType  # type: ignore[attr-defined] # python 3.10 or above
-except ImportError:
+    from sphinx.application import Sphinx
+
+if sys.version_info >= (3, 10):
+    from types import UnionType
+else:
     UnionType = None
 
-# classes that have incorrect __module__
-INVALID_BUILTIN_CLASSES = {
+# classes that have an incorrect .__module__ attribute
+_INVALID_BUILTIN_CLASSES = {
+    Context: 'contextvars.Context',  # Context.__module__ == '_contextvars'
+    ContextVar: 'contextvars.ContextVar',  # ContextVar.__module__ == '_contextvars'
+    Token: 'contextvars.Token',  # Token.__module__ == '_contextvars'
     Struct: 'struct.Struct',  # Struct.__module__ == '_struct'
-    TracebackType: 'types.TracebackType',  # TracebackType.__module__ == 'builtins'
+    # types in 'types' with <type>.__module__ == 'builtins':
+    types.AsyncGeneratorType: 'types.AsyncGeneratorType',
+    types.BuiltinFunctionType: 'types.BuiltinFunctionType',
+    types.BuiltinMethodType: 'types.BuiltinMethodType',
+    types.CellType: 'types.CellType',
+    types.ClassMethodDescriptorType: 'types.ClassMethodDescriptorType',
+    types.CodeType: 'types.CodeType',
+    types.CoroutineType: 'types.CoroutineType',
+    types.FrameType: 'types.FrameType',
+    types.FunctionType: 'types.FunctionType',
+    types.GeneratorType: 'types.GeneratorType',
+    types.GetSetDescriptorType: 'types.GetSetDescriptorType',
+    types.LambdaType: 'types.LambdaType',
+    types.MappingProxyType: 'types.MappingProxyType',
+    types.MemberDescriptorType: 'types.MemberDescriptorType',
+    types.MethodDescriptorType: 'types.MethodDescriptorType',
+    types.MethodType: 'types.MethodType',
+    types.MethodWrapperType: 'types.MethodWrapperType',
+    types.ModuleType: 'types.ModuleType',
+    types.TracebackType: 'types.TracebackType',
+    types.WrapperDescriptorType: 'types.WrapperDescriptorType',
 }
 
 
 def is_invalid_builtin_class(obj: Any) -> bool:
     """Check *obj* is an invalid built-in class."""
     try:
-        return obj in INVALID_BUILTIN_CLASSES
+        return obj in _INVALID_BUILTIN_CLASSES
     except TypeError:  # unhashable type
         return False
 
@@ -64,6 +90,30 @@ InventoryItem = tuple[
 Inventory = dict[str, dict[str, InventoryItem]]
 
 
+class ExtensionMetadata(TypedDict, total=False):
+    """The metadata returned by an extension's ``setup()`` function.
+
+    See :ref:`ext-metadata`.
+    """
+
+    version: str
+    """The extension version (default: ``'unknown version'``)."""
+    env_version: int
+    """An integer that identifies the version of env data added by the extension."""
+    parallel_read_safe: bool
+    """Indicate whether parallel reading of source files is supported
+    by the extension.
+    """
+    parallel_write_safe: bool
+    """Indicate whether parallel writing of output files is supported
+    by the extension (default: ``True``).
+    """
+
+
+if TYPE_CHECKING:
+    _ExtensionSetupFunc = Callable[[Sphinx], ExtensionMetadata]
+
+
 def get_type_hints(
     obj: Any, globalns: dict[str, Any] | None = None, localns: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
@@ -128,19 +178,15 @@ def restify(cls: type | None, mode: str = 'fully-qualified-except-typing') -> st
         elif ismock(cls):
             return f':py:class:`{modprefix}{cls.__module__}.{cls.__name__}`'
         elif is_invalid_builtin_class(cls):
-            return f':py:class:`{modprefix}{INVALID_BUILTIN_CLASSES[cls]}`'
+            return f':py:class:`{modprefix}{_INVALID_BUILTIN_CLASSES[cls]}`'
         elif inspect.isNewType(cls):
             if sys.version_info[:2] >= (3, 10):
                 # newtypes have correct module info since Python 3.10+
                 return f':py:class:`{modprefix}{cls.__module__}.{cls.__name__}`'
             else:
-                return ':py:class:`%s`' % cls.__name__
+                return f':py:class:`{cls.__name__}`'
         elif UnionType and isinstance(cls, UnionType):
-            if len(cls.__args__) > 1 and None in cls.__args__:
-                args = ' | '.join(restify(a, mode) for a in cls.__args__ if a)
-                return 'Optional[%s]' % args
-            else:
-                return ' | '.join(restify(a, mode) for a in cls.__args__)
+            return ' | '.join(restify(a, mode) for a in cls.__args__)
         elif cls.__module__ in ('__builtin__', 'builtins'):
             if hasattr(cls, '__args__'):
                 if not cls.__args__:  # Empty tuple, list, ...
@@ -149,23 +195,11 @@ def restify(cls: type | None, mode: str = 'fully-qualified-except-typing') -> st
                 concatenated_args = ', '.join(restify(arg, mode) for arg in cls.__args__)
                 return fr':py:class:`{cls.__name__}`\ [{concatenated_args}]'
             else:
-                return ':py:class:`%s`' % cls.__name__
+                return f':py:class:`{cls.__name__}`'
         elif (inspect.isgenericalias(cls)
               and cls.__module__ == 'typing'
               and cls.__origin__ is Union):  # type: ignore[attr-defined]
-            if (len(cls.__args__) > 1  # type: ignore[attr-defined]
-                    and cls.__args__[-1] is NoneType):  # type: ignore[attr-defined]
-                if len(cls.__args__) > 2:  # type: ignore[attr-defined]
-                    args = ', '.join(restify(a, mode)
-                                     for a in cls.__args__[:-1])  # type: ignore[attr-defined]
-                    return ':py:obj:`~typing.Optional`\\ [:obj:`~typing.Union`\\ [%s]]' % args
-                else:
-                    return ':py:obj:`~typing.Optional`\\ [%s]' % restify(
-                        cls.__args__[0], mode)  # type: ignore[attr-defined]
-            else:
-                args = ', '.join(restify(a, mode)
-                                 for a in cls.__args__)  # type: ignore[attr-defined]
-                return ':py:obj:`~typing.Union`\\ [%s]' % args
+            return ' | '.join(restify(a, mode) for a in cls.__args__)  # type: ignore[attr-defined]
         elif inspect.isgenericalias(cls):
             if isinstance(cls.__origin__, typing._SpecialForm):  # type: ignore[attr-defined]
                 text = restify(cls.__origin__, mode)  # type: ignore[attr-defined,arg-type]
@@ -195,14 +229,14 @@ def restify(cls: type | None, mode: str = 'fully-qualified-except-typing') -> st
                         literal_args.append(_format_literal_enum_arg(a, mode=mode))
                     else:
                         literal_args.append(repr(a))
-                text += r"\ [%s]" % ', '.join(literal_args)
+                text += fr"\ [{', '.join(literal_args)}]"
                 del literal_args
             elif cls.__args__:
-                text += r"\ [%s]" % ", ".join(restify(a, mode) for a in cls.__args__)
+                text += fr"\ [{', '.join(restify(a, mode) for a in cls.__args__)}]"
 
             return text
         elif isinstance(cls, typing._SpecialForm):
-            return f':py:obj:`~{cls.__module__}.{cls._name}`'  # type: ignore[attr-defined]
+            return f':py:obj:`~{cls.__module__}.{cls._name}`'
         elif sys.version_info[:2] >= (3, 11) and cls is typing.Any:
             # handle bpo-46998
             return f':py:obj:`~{cls.__module__}.{cls.__name__}`'
@@ -212,7 +246,7 @@ def restify(cls: type | None, mode: str = 'fully-qualified-except-typing') -> st
             else:
                 return f':py:class:`{modprefix}{cls.__module__}.{cls.__qualname__}`'
         elif isinstance(cls, ForwardRef):
-            return ':py:class:`%s`' % cls.__forward_arg__
+            return f':py:class:`{cls.__forward_arg__}`'
         else:
             # not a class (ex. TypeVar)
             if cls.__module__ == 'typing':
@@ -285,7 +319,7 @@ def stringify_annotation(
     elif ismock(annotation):
         return module_prefix + f'{annotation_module}.{annotation_name}'
     elif is_invalid_builtin_class(annotation):
-        return module_prefix + INVALID_BUILTIN_CLASSES[annotation]
+        return module_prefix + _INVALID_BUILTIN_CLASSES[annotation]
     elif str(annotation).startswith('typing.Annotated'):  # for py310+
         pass
     elif annotation_module == 'builtins' and annotation_qualname:
@@ -350,7 +384,7 @@ def stringify_annotation(
         elif qualname == 'Literal':
             from sphinx.util.inspect import isenumattribute  # lazy loading
 
-            def format_literal_arg(arg):
+            def format_literal_arg(arg: Any) -> str:
                 if isenumattribute(arg):
                     enumcls = arg.__class__
 
@@ -384,19 +418,19 @@ def _format_literal_enum_arg(arg: enum.Enum, /, *, mode: str) -> str:
         return f':py:attr:`{enum_cls.__module__}.{enum_cls.__qualname__}.{arg.name}`'
 
 
-# deprecated name -> (object to return, canonical path or empty string)
-_DEPRECATED_OBJECTS = {
-    'stringify': (stringify_annotation, 'sphinx.util.typing.stringify_annotation'),
+# 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)),
 }
 
 
-def __getattr__(name):
+def __getattr__(name: str) -> Any:
     if name not in _DEPRECATED_OBJECTS:
         msg = f'module {__name__!r} has no attribute {name!r}'
         raise AttributeError(msg)
 
     from sphinx.deprecation import _deprecation_warning
 
-    deprecated_object, canonical_name = _DEPRECATED_OBJECTS[name]
-    _deprecation_warning(__name__, name, canonical_name, remove=(8, 0))
+    deprecated_object, canonical_name, remove = _DEPRECATED_OBJECTS[name]
+    _deprecation_warning(__name__, name, canonical_name, remove=remove)
     return deprecated_object

sphinx/versioning.py

@@ -1,4 +1,5 @@
 """Implements the low-level algorithms Sphinx uses for versioning doctrees."""
+
 from __future__ import annotations
 
 import pickle
@@ -16,9 +17,11 @@ if TYPE_CHECKING:
     from docutils.nodes import Node
 
     from sphinx.application import Sphinx
+    from sphinx.util.typing import ExtensionMetadata
 
 try:
-    import Levenshtein
+    import Levenshtein  # type: ignore[import-not-found]
+
     IS_SPEEDUP = True
 except ImportError:
     IS_SPEEDUP = False
@@ -144,6 +147,7 @@ def levenshtein_distance(a: str, b: str) -> int:
 
 class UIDTransform(SphinxTransform):
     """Add UIDs to doctree for versioning."""
+
     default_priority = 880
 
     def apply(self, **kwargs: Any) -> None:
@@ -168,7 +172,7 @@ class UIDTransform(SphinxTransform):
             list(merge_doctrees(old_doctree, self.document, env.versioning_condition))
 
 
-def setup(app: Sphinx) -> dict[str, Any]:
+def setup(app: Sphinx) -> ExtensionMetadata:
     app.add_transform(UIDTransform)
 
     return {

sphinx/writers/html.py

@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
 HTMLTranslator = HTML5Translator
 
 # A good overview of the purpose behind these classes can be found here:
-# http://www.arnebrodowski.de/blog/write-your-own-restructuredtext-writer.html
+# https://www.arnebrodowski.de/blog/write-your-own-restructuredtext-writer.html
 
 
 class HTMLWriter(Writer):

sphinx/writers/html5.py

@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 # A good overview of the purpose behind these classes can be found here:
-# http://www.arnebrodowski.de/blog/write-your-own-restructuredtext-writer.html
+# https://www.arnebrodowski.de/blog/write-your-own-restructuredtext-writer.html
 
 
 def multiply_length(length: str, scale: int) -> str:
@@ -247,8 +247,8 @@ class HTML5Translator(SphinxTranslator, BaseTranslator):
         self.depart_desc_parameter(node)
 
     def visit_desc_optional(self, node: Element) -> None:
-        self.params_left_at_level = sum([isinstance(c, addnodes.desc_parameter)
-                                         for c in node.children])
+        self.params_left_at_level = sum(isinstance(c, addnodes.desc_parameter)
+                                        for c in node.children)
         self.optional_param_level += 1
         self.max_optional_param_level = self.optional_param_level
         if self.multi_line_parameter_list:
@@ -338,7 +338,7 @@ class HTML5Translator(SphinxTranslator, BaseTranslator):
         self.depart_reference(node)
 
     # overwritten -- we don't want source comments to show up in the HTML
-    def visit_comment(self, node: Element) -> None:  # type: ignore[override]
+    def visit_comment(self, node: Element) -> None:
         raise nodes.SkipNode
 
     # overwritten
@@ -475,6 +475,17 @@ class HTML5Translator(SphinxTranslator, BaseTranslator):
         self.add_fignumber(node.parent)
         if isinstance(node.parent, nodes.table):
             self.body.append('<span class="caption-text">')
+        # Partially revert https://sourceforge.net/p/docutils/code/9562/
+        if (
+                isinstance(node.parent, nodes.topic)
+                and self.settings.toc_backlinks
+                and 'contents' in node.parent['classes']
+                and self.body[-1].startswith('<a ')
+                # TODO: only remove for EPUB
+        ):
+            # remove <a class="reference internal" href="#top">
+            self.body.pop()
+            self.context[-1] = '</p>\n'
 
     def depart_title(self, node: Element) -> None:
         close_tag = self.context[-1]
@@ -589,10 +600,8 @@ class HTML5Translator(SphinxTranslator, BaseTranslator):
 
     def visit_productionlist(self, node: Element) -> None:
         self.body.append(self.starttag(node, 'pre'))
-        names = []
         productionlist = cast(Iterable[addnodes.production], node)
-        for production in productionlist:
-            names.append(production['tokenname'])
+        names = (production['tokenname'] for production in productionlist)
         maxlen = max(len(name) for name in names)
         lastname = None
         for production in productionlist:
@@ -846,13 +855,8 @@ class HTML5Translator(SphinxTranslator, BaseTranslator):
 
     def visit_manpage(self, node: Element) -> None:
         self.visit_literal_emphasis(node)
-        if self.manpages_url:
-            node['refuri'] = self.manpages_url.format(**node.attributes)
-            self.visit_reference(node)
 
     def depart_manpage(self, node: Element) -> None:
-        if self.manpages_url:
-            self.depart_reference(node)
         self.depart_literal_emphasis(node)
 
     # overwritten to add even/odd classes
@@ -928,7 +932,7 @@ class HTML5Translator(SphinxTranslator, BaseTranslator):
 
     # See Docutils r9413
     # Re-instate the footnote-reference class
-    def visit_footnote_reference(self, node):
+    def visit_footnote_reference(self, node: Element) -> None:
         href = '#' + node['refid']
         classes = ['footnote-reference', self.settings.footnote_references]
         self.body.append(self.starttag(node, 'a', suffix='', classes=classes,

sphinx/writers/latex.py

@@ -29,7 +29,7 @@ try:
     from docutils.utils.roman import toRoman
 except ImportError:
     # In Debian/Ubuntu, roman package is provided as roman, not as docutils.utils.roman
-    from roman import toRoman  # type: ignore[no-redef]
+    from roman import toRoman  # type: ignore[no-redef, import-not-found]
 
 if TYPE_CHECKING:
     from docutils.nodes import Element, Node, Text
@@ -158,7 +158,7 @@ class Table:
             return 'tabulary'
 
     def get_colspec(self) -> str:
-        """Returns a column spec of table.
+        r"""Returns a column spec of table.
 
         This is what LaTeX calls the 'preamble argument' of the used table environment.
 
@@ -321,7 +321,7 @@ class LaTeXTranslator(SphinxTranslator):
         self.elements = self.builder.context.copy()
 
         # initial section names
-        self.sectionnames = LATEXSECTIONNAMES[:]
+        self.sectionnames = LATEXSECTIONNAMES.copy()
         if self.theme.toplevel_sectioning == 'section':
             self.sectionnames.remove('chapter')
 
@@ -911,8 +911,8 @@ class LaTeXTranslator(SphinxTranslator):
         self._depart_sig_parameter(node)
 
     def visit_desc_optional(self, node: Element) -> None:
-        self.params_left_at_level = sum([isinstance(c, addnodes.desc_parameter)
-                                         for c in node.children])
+        self.params_left_at_level = sum(isinstance(c, addnodes.desc_parameter)
+                                        for c in node.children)
         self.optional_param_level += 1
         self.max_optional_param_level = self.optional_param_level
         if self.multi_line_parameter_list:
@@ -2121,14 +2121,14 @@ class LaTeXTranslator(SphinxTranslator):
         self.body.append('}}$')
 
     def visit_inline(self, node: Element) -> None:
-        classes = node.get('classes', [])
-        if classes in [['menuselection']]:
+        classes = node.get('classes', [])  # type: ignore[var-annotated]
+        if classes == ['menuselection']:
             self.body.append(r'\sphinxmenuselection{')
             self.context.append('}')
-        elif classes in [['guilabel']]:
+        elif classes == ['guilabel']:
             self.body.append(r'\sphinxguilabel{')
             self.context.append('}')
-        elif classes in [['accelerator']]:
+        elif classes == ['accelerator']:
             self.body.append(r'\sphinxaccelerator{')
             self.context.append('}')
         elif classes and not self.in_title:
@@ -2153,12 +2153,12 @@ class LaTeXTranslator(SphinxTranslator):
         pass
 
     def visit_container(self, node: Element) -> None:
-        classes = node.get('classes', [])
+        classes = node.get('classes', [])  # type: ignore[var-annotated]
         for c in classes:
             self.body.append('\n\\begin{sphinxuseclass}{%s}' % c)
 
     def depart_container(self, node: Element) -> None:
-        classes = node.get('classes', [])
+        classes = node.get('classes', [])  # type: ignore[var-annotated]
         for _c in classes:
             self.body.append('\n\\end{sphinxuseclass}')
 
@@ -2261,6 +2261,6 @@ class LaTeXTranslator(SphinxTranslator):
 
 # FIXME: Workaround to avoid circular import
 # refs: https://github.com/sphinx-doc/sphinx/issues/5433
-from sphinx.builders.latex.nodes import (  # noqa: E402  # isort:skip
+from sphinx.builders.latex.nodes import (  # NoQA: E402  # isort:skip
     HYPERLINK_SUPPORT_NODES, captioned_literal_block, footnotetext,
 )

sphinx/writers/manpage.py

@@ -49,12 +49,13 @@ class NestedInlineTransform:
         <strong>foo=</strong><emphasis>var</emphasis>
         <strong>&bar=</strong><emphasis>2</emphasis>
     """
+
     def __init__(self, document: nodes.document) -> None:
         self.document = document
 
     def apply(self, **kwargs: Any) -> None:
         matcher = NodeMatcher(nodes.literal, nodes.emphasis, nodes.strong)
-        for node in list(self.document.findall(matcher)):  # type: nodes.TextElement
+        for node in list(matcher.findall(self.document)):
             if any(matcher(subnode) for subnode in node):
                 pos = node.parent.index(node)
                 for subnode in reversed(list(node)):
@@ -244,7 +245,7 @@ class ManualPageTranslator(SphinxTranslator, BaseTranslator):
             super().visit_term(node)
 
     # overwritten -- we don't want source comments to show up
-    def visit_comment(self, node: Element) -> None:  # type: ignore[override]
+    def visit_comment(self, node: Element) -> None:
         raise nodes.SkipNode
 
     # overwritten -- added ensure_eol()
@@ -271,12 +272,10 @@ class ManualPageTranslator(SphinxTranslator, BaseTranslator):
 
     def visit_productionlist(self, node: Element) -> None:
         self.ensure_eol()
-        names = []
         self.in_productionlist += 1
         self.body.append('.sp\n.nf\n')
         productionlist = cast(Iterable[addnodes.production], node)
-        for production in productionlist:
-            names.append(production['tokenname'])
+        names = (production['tokenname'] for production in productionlist)
         maxlen = max(len(name) for name in names)
         lastname = None
         for production in productionlist:
@@ -309,13 +308,17 @@ class ManualPageTranslator(SphinxTranslator, BaseTranslator):
 
     # overwritten -- don't visit inner marked up nodes
     def visit_reference(self, node: Element) -> None:
+        uri = node.get('refuri', '')
+        if uri:
+            # OSC 8 link start (using groff's device control directive).
+            self.body.append(fr"\X'tty: link {uri}'")
+
         self.body.append(self.defs['reference'][0])
         # avoid repeating escaping code... fine since
         # visit_Text calls astext() and only works on that afterwards
-        self.visit_Text(node)  # type: ignore[arg-type]
+        self.visit_Text(node)
         self.body.append(self.defs['reference'][1])
 
-        uri = node.get('refuri', '')
         if uri.startswith(('mailto:', 'http:', 'https:', 'ftp:')):
             # if configured, put the URL after the link
             if self.config.man_show_urls and node.astext() != uri:
@@ -325,6 +328,9 @@ class ManualPageTranslator(SphinxTranslator, BaseTranslator):
                     ' <',
                     self.defs['strong'][0], uri, self.defs['strong'][1],
                     '>'])
+        if uri:
+            # OSC 8 link end.
+            self.body.append(r"\X'tty: link'")
         raise nodes.SkipNode
 
     def visit_number_reference(self, node: Element) -> None:

sphinx/writers/texinfo.py

@@ -96,7 +96,8 @@ def find_subsections(section: Element) -> list[nodes.section]:
 
 def smart_capwords(s: str, sep: str | None = None) -> str:
     """Like string.capwords() but does not capitalize words that already
-    contain a capital letter."""
+    contain a capital letter.
+    """
     words = s.split(sep)
     for i, word in enumerate(words):
         if all(x.islower() for x in word):
@@ -106,6 +107,7 @@ def smart_capwords(s: str, sep: str | None = None) -> str:
 
 class TexinfoWriter(writers.Writer):
     """Texinfo writer for generating Texinfo documents."""
+
     supported = ('texinfo', 'texi')
 
     settings_spec: tuple[str, Any, tuple[tuple[str, list[str], dict[str, str]], ...]] = (
@@ -255,7 +257,8 @@ class TexinfoTranslator(SphinxTranslator):
     def collect_node_names(self) -> None:
         """Generates a unique id for each section.
 
-        Assigns the attribute ``node_name`` to each section."""
+        Assigns the attribute ``node_name`` to each section.
+        """
 
         def add_node_name(name: str) -> str:
             node_id = self.escape_id(name)
@@ -278,7 +281,7 @@ class TexinfoTranslator(SphinxTranslator):
                         for name, content in self.indices]
         # each section is also a node
         for section in self.document.findall(nodes.section):
-            title = cast(nodes.TextElement, section.next_node(nodes.Titular))
+            title = cast(nodes.TextElement, section.next_node(nodes.Titular))  # type: ignore[type-var]
             name = title.astext() if title else '<untitled>'
             section['node_name'] = add_node_name(name)
 
@@ -288,7 +291,7 @@ class TexinfoTranslator(SphinxTranslator):
         targets: list[Element] = [self.document]
         targets.extend(self.document.findall(nodes.section))
         for node in targets:
-            assert 'node_name' in node and node['node_name']  # NoQA: PT018
+            assert node.get('node_name', False)
             entries = [s['node_name'] for s in find_subsections(node)]
             node_menus[node['node_name']] = entries
         # try to find a suitable "Top" node
@@ -352,7 +355,8 @@ class TexinfoTranslator(SphinxTranslator):
 
     def escape_arg(self, s: str) -> str:
         """Return an escaped string suitable for use as an argument
-        to a Texinfo command."""
+        to a Texinfo command.
+        """
         s = self.escape(s)
         # commas are the argument delimiters
         s = s.replace(',', '@comma{}')
@@ -430,7 +434,7 @@ class TexinfoTranslator(SphinxTranslator):
             entries = self.node_menus[name]
             if not entries:
                 return
-            self.body.append(f'\n{self.escape(self.node_names[name], )}\n\n')
+            self.body.append(f'\n{self.escape(self.node_names[name])}\n\n')
             self.add_menu_entries(entries)
             for subentry in entries:
                 _add_detailed_menu(subentry)
@@ -524,7 +528,7 @@ class TexinfoTranslator(SphinxTranslator):
         try:
             sid = self.short_ids[id]
         except KeyError:
-            sid = hex(len(self.short_ids))[2:]
+            sid = f'{len(self.short_ids):x}'
             self.short_ids[id] = sid
         return sid
 
@@ -1287,11 +1291,10 @@ class TexinfoTranslator(SphinxTranslator):
 
     def visit_productionlist(self, node: Element) -> None:
         self.visit_literal_block(None)
-        names = []
         productionlist = cast(Iterable[addnodes.production], node)
-        for production in productionlist:
-            names.append(production['tokenname'])
+        names = (production['tokenname'] for production in productionlist)
         maxlen = max(len(name) for name in names)
+
         for production in productionlist:
             if production['tokenname']:
                 for id in production.get('ids'):