Sphinx 8.0.2__py3-none-any.whl → 8.1.1__py3-none-any.whl

sphinx/writers/latex.py

@@ -10,12 +10,11 @@ import re
 from collections import defaultdict
 from collections.abc import Iterable
 from os import path
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from docutils import nodes, writers
 
 from sphinx import addnodes, highlighting
-from sphinx.domains.std import StandardDomain
 from sphinx.errors import SphinxError
 from sphinx.locale import _, __, admonitionlabels
 from sphinx.util import logging, texescape
@@ -42,16 +41,25 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 MAX_CITATION_LABEL_LENGTH = 8
-LATEXSECTIONNAMES = ["part", "chapter", "section", "subsection",
-                     "subsubsection", "paragraph", "subparagraph"]
-ENUMERATE_LIST_STYLE = defaultdict(lambda: r'\arabic',
-                                   {
-                                       'arabic': r'\arabic',
-                                       'loweralpha': r'\alph',
-                                       'upperalpha': r'\Alph',
-                                       'lowerroman': r'\roman',
-                                       'upperroman': r'\Roman',
-                                   })
+LATEXSECTIONNAMES = [
+    'part',
+    'chapter',
+    'section',
+    'subsection',
+    'subsubsection',
+    'paragraph',
+    'subparagraph',
+]
+ENUMERATE_LIST_STYLE = defaultdict(
+    lambda: r'\arabic',
+    {
+        'arabic': r'\arabic',
+        'loweralpha': r'\alph',
+        'upperalpha': r'\Alph',
+        'lowerroman': r'\roman',
+        'upperroman': r'\Roman',
+    },
+)
 
 CR = '\n'
 BLANKLINE = '\n\n'
@@ -66,16 +74,19 @@ class UnsupportedError(SphinxError):
     category = 'Markup is unsupported in LaTeX'
 
 
-class LaTeXWriter(writers.Writer):  # type: ignore[misc]
-
+class LaTeXWriter(writers.Writer):  # type: ignore[type-arg]
     supported = ('sphinxlatex',)
 
-    settings_spec = ('LaTeX writer options', '', (
-        ('Document name', ['--docname'], {'default': ''}),
-        ('Document class', ['--docclass'], {'default': 'manual'}),
-        ('Author', ['--author'], {'default': ''}),
-    ))
-    settings_defaults: dict[str, Any] = {}
+    settings_spec = (
+        'LaTeX writer options',
+        '',
+        (
+            ('Document name', ['--docname'], {'default': ''}),
+            ('Document class', ['--docclass'], {'default': 'manual'}),
+            ('Author', ['--author'], {'default': ''}),
+        ),
+    )
+    settings_defaults: ClassVar[dict[str, Any]] = {}
 
     theme: Theme
 
@@ -84,13 +95,17 @@ class LaTeXWriter(writers.Writer):  # type: ignore[misc]
         self.builder = builder
 
     def translate(self) -> None:
-        visitor = self.builder.create_translator(self.document, self.builder, self.theme)
+        assert isinstance(self.document, nodes.document)
+        visitor = self.builder.create_translator(
+            self.document, self.builder, self.theme
+        )
         self.document.walkabout(visitor)
         self.output = cast(LaTeXTranslator, visitor).astext()
 
 
 # Helper classes
 
+
 class Table:
     """A table data"""
 
@@ -152,7 +167,9 @@ class Table:
             return 'tabular'
         elif self.colspec:
             return 'tabulary'
-        elif self.has_problematic or (self.colwidths and 'colwidths-given' in self.classes):
+        elif self.has_problematic or (
+            self.colwidths and 'colwidths-given' in self.classes
+        ):
             return 'tabular'
         else:
             return 'tabulary'
@@ -177,14 +194,20 @@ class Table:
             colspecs = [r'\X{%d}{%d}' % (width, total) for width in self.colwidths]
             return f'{{{_colsep}{_colsep.join(colspecs)}{_colsep}}}' + CR
         elif self.has_problematic:
-            return r'{%s*{%d}{\X{1}{%d}%s}}' % (_colsep, self.colcount,
-                                                self.colcount, _colsep) + CR
+            return (
+                r'{%s*{%d}{\X{1}{%d}%s}}'
+                % (_colsep, self.colcount, self.colcount, _colsep)
+                + CR
+            )
         elif self.get_table_type() == 'tabulary':
             # sphinx.sty sets T to be J by default.
             return '{' + _colsep + (('T' + _colsep) * self.colcount) + '}' + CR
         elif self.has_oldproblematic:
-            return r'{%s*{%d}{\X{1}{%d}%s}}' % (_colsep, self.colcount,
-                                                self.colcount, _colsep) + CR
+            return (
+                r'{%s*{%d}{\X{1}{%d}%s}}'
+                % (_colsep, self.colcount, self.colcount, _colsep)
+                + CR
+            )
         else:
             return '{' + _colsep + (('l' + _colsep) * self.colcount) + '}' + CR
 
@@ -200,7 +223,9 @@ class Table:
                 self.cells[(self.row + row, self.col + col)] = self.cell_id
 
     def cell(
-        self, row: int | None = None, col: int | None = None,
+        self,
+        row: int | None = None,
+        col: int | None = None,
     ) -> TableCell | None:
         """Returns a cell object (i.e. rectangular area) containing given position.
 
@@ -266,22 +291,22 @@ def rstdim_to_latexdim(width_str: str, scale: int = 100) -> str:
     amount, unit = match.groups()[:2]
     if scale == 100:
         float(amount)  # validate amount is float
-        if unit in ('', "px"):
-            res = r"%s\sphinxpxdimen" % amount
+        if unit in ('', 'px'):
+            res = r'%s\sphinxpxdimen' % amount
         elif unit == 'pt':
             res = '%sbp' % amount  # convert to 'bp'
-        elif unit == "%":
-            res = r"%.3f\linewidth" % (float(amount) / 100.0)
+        elif unit == '%':
+            res = r'%.3f\linewidth' % (float(amount) / 100.0)
     else:
         amount_float = float(amount) * scale / 100.0
-        if unit in ('', "px"):
-            res = r"%.5f\sphinxpxdimen" % amount_float
+        if unit in ('', 'px'):
+            res = r'%.5f\sphinxpxdimen' % amount_float
         elif unit == 'pt':
             res = '%.5fbp' % amount_float
-        elif unit == "%":
-            res = r"%.5f\linewidth" % (amount_float / 100.0)
+        elif unit == '%':
+            res = r'%.5f\linewidth' % (amount_float / 100.0)
         else:
-            res = f"{amount_float:.5f}{unit}"
+            res = f'{amount_float:.5f}{unit}'
     return res
 
 
@@ -292,8 +317,9 @@ class LaTeXTranslator(SphinxTranslator):
     # default is originally 3. For book/report, 2 is already LaTeX default.
     ignore_missing_images = False
 
-    def __init__(self, document: nodes.document, builder: LaTeXBuilder,
-                 theme: Theme) -> None:
+    def __init__(
+        self, document: nodes.document, builder: LaTeXBuilder, theme: Theme
+    ) -> None:
         super().__init__(document, builder)
         self.body: list[str] = []
         self.theme = theme
@@ -330,46 +356,63 @@ class LaTeXTranslator(SphinxTranslator):
         self.top_sectionlevel = 1
         if self.config.latex_toplevel_sectioning:
             try:
-                self.top_sectionlevel = \
-                    self.sectionnames.index(self.config.latex_toplevel_sectioning)
+                self.top_sectionlevel = self.sectionnames.index(
+                    self.config.latex_toplevel_sectioning
+                )
             except ValueError:
-                logger.warning(__('unknown %r toplevel_sectioning for class %r'),
-                               self.config.latex_toplevel_sectioning, self.theme.docclass)
+                logger.warning(
+                    __('unknown %r toplevel_sectioning for class %r'),
+                    self.config.latex_toplevel_sectioning,
+                    self.theme.docclass,
+                )
 
         if self.config.numfig:
             self.numfig_secnum_depth = self.config.numfig_secnum_depth
             if self.numfig_secnum_depth > 0:  # default is 1
                 # numfig_secnum_depth as passed to sphinx.sty indices same names as in
                 # LATEXSECTIONNAMES but with -1 for part, 0 for chapter, 1 for section...
-                if len(self.sectionnames) < len(LATEXSECTIONNAMES) and \
-                   self.top_sectionlevel > 0:
+                if (
+                    len(self.sectionnames) < len(LATEXSECTIONNAMES)
+                    and self.top_sectionlevel > 0
+                ):
                     self.numfig_secnum_depth += self.top_sectionlevel
                 else:
                     self.numfig_secnum_depth += self.top_sectionlevel - 1
                 # this (minus one) will serve as minimum to LaTeX's secnumdepth
-                self.numfig_secnum_depth = min(self.numfig_secnum_depth,
-                                               len(LATEXSECTIONNAMES) - 1)
+                self.numfig_secnum_depth = min(
+                    self.numfig_secnum_depth, len(LATEXSECTIONNAMES) - 1
+                )
                 # if passed key value is < 1 LaTeX will act as if 0; see sphinx.sty
                 sphinxpkgoptions.append('numfigreset=%s' % self.numfig_secnum_depth)
             else:
                 sphinxpkgoptions.append('nonumfigreset')
 
         if self.config.numfig and self.config.math_numfig:
-            sphinxpkgoptions.append('mathnumfig')
-
-        if (self.config.language not in {'en', 'ja'} and
-                'fncychap' not in self.config.latex_elements):
+            sphinxpkgoptions.extend([
+                'mathnumfig',
+                'mathnumsep={%s}' % self.config.math_numsep,
+            ])
+
+        if (
+            self.config.language not in {'en', 'ja'}
+            and 'fncychap' not in self.config.latex_elements
+        ):
             # use Sonny style if any language specified (except English)
-            self.elements['fncychap'] = (r'\usepackage[Sonny]{fncychap}' + CR +
-                                         r'\ChNameVar{\Large\normalfont\sffamily}' + CR +
-                                         r'\ChTitleVar{\Large\normalfont\sffamily}')
+            self.elements['fncychap'] = (
+                r'\usepackage[Sonny]{fncychap}'
+                + CR
+                + r'\ChNameVar{\Large\normalfont\sffamily}'
+                + CR
+                + r'\ChTitleVar{\Large\normalfont\sffamily}'
+            )
 
         self.babel = self.builder.babel
         if not self.babel.is_supported_language():
             # emit warning if specified language is invalid
             # (only emitting, nothing changed to processing)
-            logger.warning(__('no Babel option known for language %r'),
-                           self.config.language)
+            logger.warning(
+                __('no Babel option known for language %r'), self.config.language
+            )
 
         minsecnumdepth = self.secnumdepth  # 2 from legacy sphinx manual/howto
         if self.document.get('tocdepth'):
@@ -380,8 +423,10 @@ class LaTeXTranslator(SphinxTranslator):
             #   tocdepth =  2: show parts, chapters, sections and subsections
             #   ...
             tocdepth = self.document.get('tocdepth', 999) + self.top_sectionlevel - 2
-            if len(self.sectionnames) < len(LATEXSECTIONNAMES) and \
-               self.top_sectionlevel > 0:
+            if (
+                len(self.sectionnames) < len(LATEXSECTIONNAMES)
+                and self.top_sectionlevel > 0
+            ):
                 tocdepth += 1  # because top_sectionlevel is shifted by -1
             if tocdepth > len(LATEXSECTIONNAMES) - 2:  # default is 5 <-> subparagraph
                 logger.warning(__('too large :maxdepth:, ignored.'))
@@ -394,26 +439,30 @@ class LaTeXTranslator(SphinxTranslator):
             minsecnumdepth = max(minsecnumdepth, self.numfig_secnum_depth - 1)
 
         if minsecnumdepth > self.secnumdepth:
-            self.elements['secnumdepth'] = r'\setcounter{secnumdepth}{%d}' %\
-                                           minsecnumdepth
+            self.elements['secnumdepth'] = (
+                r'\setcounter{secnumdepth}{%d}' % minsecnumdepth
+            )
 
         contentsname = document.get('contentsname')
         if contentsname:
-            self.elements['contentsname'] = self.babel_renewcommand(r'\contentsname',
-                                                                    contentsname)
+            self.elements['contentsname'] = self.babel_renewcommand(
+                r'\contentsname', contentsname
+            )
 
         if self.elements['maxlistdepth']:
             sphinxpkgoptions.append('maxlistdepth=%s' % self.elements['maxlistdepth'])
         if sphinxpkgoptions:
             self.elements['sphinxpkgoptions'] = '[,%s]' % ','.join(sphinxpkgoptions)
         if self.elements['sphinxsetup']:
-            self.elements['sphinxsetup'] = (r'\sphinxsetup{%s}' % self.elements['sphinxsetup'])
+            self.elements['sphinxsetup'] = (
+                r'\sphinxsetup{%s}' % self.elements['sphinxsetup']
+            )
         if self.elements['extraclassoptions']:
-            self.elements['classoptions'] += ',' + \
-                                             self.elements['extraclassoptions']
+            self.elements['classoptions'] += ',' + self.elements['extraclassoptions']
 
-        self.highlighter = highlighting.PygmentsBridge('latex', self.config.pygments_style,
-                                                       latex_engine=self.config.latex_engine)
+        self.highlighter = highlighting.PygmentsBridge(
+            'latex', self.config.pygments_style, latex_engine=self.config.latex_engine
+        )
         self.context: list[Any] = []
         self.descstack: list[str] = []
         self.tables: list[Table] = []
@@ -443,10 +492,13 @@ class LaTeXTranslator(SphinxTranslator):
     def hypertarget(self, id: str, withdoc: bool = True, anchor: bool = True) -> str:
         if withdoc:
             id = self.curfilestack[-1] + ':' + id
-        return (r'\phantomsection' if anchor else '') + r'\label{%s}' % self.idescape(id)
+        escaped_id = self.idescape(id)
+        return (r'\phantomsection' if anchor else '') + r'\label{%s}' % escaped_id
 
     def hypertarget_to(self, node: Element, anchor: bool = False) -> str:
-        labels = ''.join(self.hypertarget(node_id, anchor=False) for node_id in node['ids'])
+        labels = ''.join(
+            self.hypertarget(node_id, anchor=False) for node_id in node['ids']
+        )
         if anchor:
             return r'\phantomsection' + labels
         else:
@@ -462,9 +514,9 @@ class LaTeXTranslator(SphinxTranslator):
         return texescape.escape(s, self.config.latex_engine)
 
     def idescape(self, id: str) -> str:
-        return r'\detokenize{%s}' % str(id).translate(tex_replace_map).\
-            encode('ascii', 'backslashreplace').decode('ascii').\
-            replace('\\', '_')
+        id = str(id).translate(tex_replace_map)
+        id = id.encode('ascii', 'backslashreplace').decode('ascii')
+        return r'\detokenize{%s}' % id.replace('\\', '_')
 
     def babel_renewcommand(self, command: str, definition: str) -> str:
         if self.elements['multilingual']:
@@ -474,10 +526,12 @@ class LaTeXTranslator(SphinxTranslator):
             prefix = ''
             suffix = ''
 
-        return fr'{prefix}\renewcommand{{{command}}}{{{definition}}}{suffix}' + CR
+        return rf'{prefix}\renewcommand{{{command}}}{{{definition}}}{suffix}' + CR
 
     def generate_indices(self) -> str:
-        def generate(content: list[tuple[str, list[IndexEntry]]], collapsed: bool) -> None:
+        def generate(
+            content: list[tuple[str, list[IndexEntry]]], collapsed: bool
+        ) -> None:
             ret.append(r'\begin{sphinxtheindex}' + CR)
             ret.append(r'\let\bigletter\sphinxstyleindexlettergroup' + CR)
             for i, (letter, entries) in enumerate(content):
@@ -487,13 +541,19 @@ class LaTeXTranslator(SphinxTranslator):
                 for entry in entries:
                     if not entry[3]:
                         continue
-                    ret.append(r'\item\relax\sphinxstyleindexentry{%s}' %
-                               self.encode(entry[0]))
+                    ret.append(
+                        r'\item\relax\sphinxstyleindexentry{%s}' % self.encode(entry[0])
+                    )
                     if entry[4]:
                         # add "extra" info
-                        ret.append(r'\sphinxstyleindexextra{%s}' % self.encode(entry[4]))
-                    ret.append(r'\sphinxstyleindexpageref{%s:%s}' %
-                               (entry[2], self.idescape(entry[3])) + CR)
+                        ret.append(
+                            r'\sphinxstyleindexextra{%s}' % self.encode(entry[4])
+                        )
+                    ret.append(
+                        r'\sphinxstyleindexpageref{%s:%s}'
+                        % (entry[2], self.idescape(entry[3]))
+                        + CR
+                    )
             ret.append(r'\end{sphinxtheindex}' + CR)
 
         ret = []
@@ -504,16 +564,18 @@ class LaTeXTranslator(SphinxTranslator):
                 indices_config = frozenset(indices_config)
             else:
                 check_names = False
-            for domain_name in sorted(self.builder.env.domains):
-                domain = self.builder.env.domains[domain_name]
+            for domain in self.builder.env.domains.sorted():
                 for index_cls in domain.indices:
                     index_name = f'{domain.name}-{index_cls.name}'
                     if check_names and index_name not in indices_config:
                         continue
                     content, collapsed = index_cls(domain).generate(
-                        self.builder.docnames)
+                        self.builder.docnames
+                    )
                     if content:
-                        ret.append(r'\renewcommand{\indexname}{%s}' % index_cls.localname + CR)
+                        ret.append(
+                            r'\renewcommand{\indexname}{%s}' % index_cls.localname + CR
+                        )
                         generate(content, collapsed)
 
         return ''.join(ret)
@@ -521,15 +583,17 @@ class LaTeXTranslator(SphinxTranslator):
     def render(self, template_name: str, variables: dict[str, Any]) -> str:
         renderer = LaTeXRenderer(latex_engine=self.config.latex_engine)
         for template_dir in self.config.templates_path:
-            template = path.join(self.builder.confdir, template_dir,
-                                 template_name)
+            template = path.join(self.builder.confdir, template_dir, template_name)
             if path.exists(template):
                 return renderer.render(template, variables)
             elif template.endswith('.jinja'):
                 legacy_template = template.removesuffix('.jinja') + '_t'
                 if path.exists(legacy_template):
-                    logger.warning(__('template %s not found; loading from legacy %s instead'),
-                                   template_name, legacy_template)
+                    logger.warning(
+                        __('template %s not found; loading from legacy %s instead'),
+                        template_name,
+                        legacy_template,
+                    )
                     return renderer.render(legacy_template, variables)
 
         return renderer.render(template_name, variables)
@@ -572,8 +636,7 @@ class LaTeXTranslator(SphinxTranslator):
         self.body.append(BLANKLINE)
 
     def depart_section(self, node: Element) -> None:
-        self.sectionlevel = max(self.sectionlevel - 1,
-                                self.top_sectionlevel - 1)
+        self.sectionlevel = max(self.sectionlevel - 1, self.top_sectionlevel - 1)
 
     def visit_problematic(self, node: Element) -> None:
         self.body.append(r'{\color{red}\bfseries{}')
@@ -582,13 +645,23 @@ class LaTeXTranslator(SphinxTranslator):
         self.body.append('}')
 
     def visit_topic(self, node: Element) -> None:
-        self.in_minipage = 1
-        self.body.append(CR + r'\begin{sphinxShadowBox}' + CR)
+        self.in_minipage += 1
+        if 'contents' in node.get('classes', []):
+            self.body.append(CR + r'\begin{sphinxcontents}' + CR)
+            self.context.append(r'\end{sphinxcontents}' + CR)
+        else:
+            self.body.append(CR + r'\begin{sphinxtopic}' + CR)
+            self.context.append(r'\end{sphinxtopic}' + CR)
 
     def depart_topic(self, node: Element) -> None:
-        self.in_minipage = 0
-        self.body.append(r'\end{sphinxShadowBox}' + CR)
-    visit_sidebar = visit_topic
+        self.in_minipage -= 1
+        self.body.append(self.context.pop())
+
+    def visit_sidebar(self, node: Element) -> None:
+        self.in_minipage += 1
+        self.body.append(CR + r'\begin{sphinxsidebar}' + CR)
+        self.context.append(r'\end{sphinxsidebar}' + CR)
+
     depart_sidebar = depart_topic
 
     def visit_glossary(self, node: Element) -> None:
@@ -630,10 +703,13 @@ class LaTeXTranslator(SphinxTranslator):
             raise nodes.SkipNode
         if isinstance(parent, nodes.section):
             if self.this_is_the_title:
-                if len(node.children) != 1 and not isinstance(node.children[0],
-                                                              nodes.Text):
-                    logger.warning(__('document title is not a single Text node'),
-                                   location=node)
+                if (
+                    len(node.children) != 1
+                    and not isinstance(node.children[0], nodes.Text)
+                ):  # fmt: skip
+                    logger.warning(
+                        __('document title is not a single Text node'), location=node
+                    )
                 if not self.elements['title']:
                     # text needs to be escaped since it is inserted into
                     # the output literally
@@ -642,16 +718,19 @@ class LaTeXTranslator(SphinxTranslator):
                 raise nodes.SkipNode
             short = ''
             if any(node.findall(nodes.image)):
-                short = ('[%s]' % self.escape(' '.join(clean_astext(node).split())))
+                short = '[%s]' % self.escape(' '.join(clean_astext(node).split()))
 
             try:
-                self.body.append(fr'\{self.sectionnames[self.sectionlevel]}{short}{{')
+                self.body.append(rf'\{self.sectionnames[self.sectionlevel]}{short}{{')
             except IndexError:
                 # just use "subparagraph", it's not numbered anyway
-                self.body.append(fr'\{self.sectionnames[-1]}{short}{{')
+                self.body.append(rf'\{self.sectionnames[-1]}{short}{{')
             self.context.append('}' + CR + self.hypertarget_to(node.parent))
         elif isinstance(parent, nodes.topic):
-            self.body.append(r'\sphinxstyletopictitle{')
+            if 'contents' in parent.get('classes', []):
+                self.body.append(r'\sphinxstylecontentstitle{')
+            else:
+                self.body.append(r'\sphinxstyletopictitle{')
             self.context.append('}' + CR)
         elif isinstance(parent, nodes.sidebar):
             self.body.append(r'\sphinxstylesidebartitle{')
@@ -663,9 +742,13 @@ class LaTeXTranslator(SphinxTranslator):
             # Redirect body output until title is finished.
             self.pushbody([])
         else:
-            logger.warning(__('encountered title node not in section, topic, table, '
-                              'admonition or sidebar'),
-                           location=node)
+            logger.warning(
+                __(
+                    'encountered title node not in section, topic, table, '
+                    'admonition or sidebar'
+                ),
+                location=node,
+            )
             self.body.append(r'\sphinxstyleothertitle{')
             self.context.append('}' + CR)
         self.in_title = 1
@@ -743,26 +826,37 @@ class LaTeXTranslator(SphinxTranslator):
 
                 if multi_tp_list:
                     if multi_arglist:
-                        self.body.append(CR + r'\pysigwithonelineperargwithonelinepertparg{')
+                        self.body.append(
+                            CR
+                            + r'\pysigwithonelineperargwithonelinepertparg'
+                            + CR
+                            + '{'
+                        )
                     else:
-                        self.body.append(CR + r'\pysiglinewithargsretwithonelinepertparg{')
+                        self.body.append(
+                            CR + r'\pysiglinewithargsretwithonelinepertparg' + CR + '{'
+                        )
                 else:
                     if multi_arglist:
-                        self.body.append(CR + r'\pysigwithonelineperargwithtypelist{')
+                        self.body.append(
+                            CR + r'\pysigwithonelineperargwithtypelist' + CR + '{'
+                        )
                     else:
-                        self.body.append(CR + r'\pysiglinewithargsretwithtypelist{')
+                        self.body.append(
+                            CR + r'\pysiglinewithargsretwithtypelist' + CR + '{'
+                        )
                 break
 
             if isinstance(child, addnodes.desc_parameterlist):
                 # arglist only: \macro{name}{arglist}{retann}
                 if has_multi_line(child):
-                    self.body.append(CR + r'\pysigwithonelineperarg{')
+                    self.body.append(CR + r'\pysigwithonelineperarg' + CR + '{')
                 else:
-                    self.body.append(CR + r'\pysiglinewithargsret{')
+                    self.body.append(CR + r'\pysiglinewithargsret' + CR + '{')
                 break
         else:
             # no tp_list, no arglist: \macro{name}
-            self.body.append(CR + r'\pysigline{')
+            self.body.append(CR + r'\pysigline' + CR + '{')
 
     def _depart_signature_line(self, node: Element) -> None:
         self.body.append('}')
@@ -838,7 +932,9 @@ class LaTeXTranslator(SphinxTranslator):
     def depart_desc_returns(self, node: Element) -> None:
         self.body.append(r'}')
 
-    def _visit_sig_parameter_list(self, node: Element, parameter_group: type[Element]) -> None:
+    def _visit_sig_parameter_list(
+        self, node: Element, parameter_group: type[Element]
+    ) -> None:
         """Visit a signature parameters or type parameters list.
 
         The *parameter_group* value is the type of a child node acting as a required parameter
@@ -853,7 +949,9 @@ class LaTeXTranslator(SphinxTranslator):
         self.param_group_index = 0
         # Counts as what we call a parameter group either a required parameter, or a
         # set of contiguous optional ones.
-        self.list_is_required_param = [isinstance(c, parameter_group) for c in node.children]
+        self.list_is_required_param = [
+            isinstance(c, parameter_group) for c in node.children
+        ]
         # How many required parameters are left.
         self.required_params_left = sum(self.list_is_required_param)
         self.param_separator = r'\sphinxparamcomma '
@@ -863,26 +961,32 @@ class LaTeXTranslator(SphinxTranslator):
         if self.has_tp_list:
             if self.orphan_tp_list:
                 # close type parameters list (#2)
-                self.body.append('}{')
+                self.body.append('}' + CR + '{')
                 # empty parameters list argument (#3)
                 return
         else:
             # close name argument (#1), open parameters list argument (#2)
-            self.body.append('}{')
+            self.body.append('}' + CR + '{')
         self._visit_sig_parameter_list(node, addnodes.desc_parameter)
 
     def depart_desc_parameterlist(self, node: Element) -> None:
         # close parameterlist, open return annotation
-        self.body.append('}{')
+        assert not self.orphan_tp_list
+        self.body.append('}' + CR + '{')
 
     def visit_desc_type_parameter_list(self, node: Element) -> None:
         # close name argument (#1), open type parameters list argument (#2)
-        self.body.append('}{')
+        self.body.append('}' + CR + '{')
         self._visit_sig_parameter_list(node, addnodes.desc_type_parameter)
 
     def depart_desc_type_parameter_list(self, node: Element) -> None:
-        # close type parameters list, open parameters list argument (#3)
-        self.body.append('}{')
+        if self.orphan_tp_list:
+            # this node next sibling isn't a desc_parameterlist, there are no parameters:
+            # close the type list, output an empty parameter list, open return annotation.
+            self.body.append('}' + CR + '{}' + CR + '{')
+        else:
+            # close type parameters list, open parameters list argument (#3)
+            self.body.append('}' + CR + '{')
 
     def _visit_sig_parameter(self, node: Element, parameter_macro: str) -> None:
         if self.is_first_param:
@@ -901,13 +1005,18 @@ class LaTeXTranslator(SphinxTranslator):
             self.body.append('}')
         is_required = self.list_is_required_param[self.param_group_index]
         if self.multi_line_parameter_list:
-            is_last_group = self.param_group_index + 1 == len(self.list_is_required_param)
+            len_lirp = len(self.list_is_required_param)
+            is_last_group = self.param_group_index + 1 == len_lirp
             next_is_required = (
                 not is_last_group
                 and self.list_is_required_param[self.param_group_index + 1]
             )
             opt_param_left_at_level = self.params_left_at_level > 0
-            if opt_param_left_at_level or is_required and (is_last_group or next_is_required):
+            if (
+                opt_param_left_at_level
+                or is_required
+                and (is_last_group or next_is_required)
+            ):
                 self.body.append(self.param_separator)
 
         elif self.required_params_left:
@@ -929,8 +1038,9 @@ 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:
@@ -966,7 +1076,9 @@ class LaTeXTranslator(SphinxTranslator):
 
     def visit_seealso(self, node: Element) -> None:
         self.body.append(BLANKLINE)
-        self.body.append(r'\begin{sphinxseealso}{%s:}' % admonitionlabels['seealso'] + CR)
+        self.body.append(
+            r'\begin{sphinxseealso}{%s:}' % admonitionlabels['seealso'] + CR
+        )
         self.no_latex_floats += 1
         if self.table:
             self.table.has_problematic = True
@@ -990,7 +1102,7 @@ class LaTeXTranslator(SphinxTranslator):
                     __('unsupported rubric heading level: %s'),
                     level,
                     type='latex',
-                    location=node
+                    location=node,
                 )
 
         self.body.append(rf'\{tag}*{{')
@@ -1034,15 +1146,17 @@ class LaTeXTranslator(SphinxTranslator):
             assert self.table is not None
             if self.table.get_table_type() == 'longtable':
                 raise UnsupportedError(
-                    '%s:%s: longtable does not support nesting a table.' %
-                    (self.curfilestack[-1], node.line or ''))
+                    '%s:%s: longtable does not support nesting a table.'
+                    % (self.curfilestack[-1], node.line or '')
+                )
             # change type of parent table to tabular
             # see https://groups.google.com/d/msg/sphinx-users/7m3NeOBixeo/9LKP2B4WBQAJ
             self.table.has_problematic = True
         elif len(self.tables) > 2:
             raise UnsupportedError(
-                '%s:%s: deeply nested tables are not implemented.' %
-                (self.curfilestack[-1], node.line or ''))
+                '%s:%s: deeply nested tables are not implemented.'
+                % (self.curfilestack[-1], node.line or '')
+            )
 
         table = Table(node)
         self.tables.append(table)
@@ -1060,16 +1174,22 @@ class LaTeXTranslator(SphinxTranslator):
                 table.styles.append('novlines')
                 table.colsep = ''
             if 'colwidths-given' in node.get('classes', []):
-                logger.info(__('both tabularcolumns and :widths: option are given. '
-                               ':widths: is ignored.'), location=node)
+                logger.info(
+                    __(
+                        'both tabularcolumns and :widths: option are given. '
+                        ':widths: is ignored.'
+                    ),
+                    location=node,
+                )
         self.next_table_colspec = None
 
     def depart_table(self, node: Element) -> None:
         assert self.table is not None
         labels = self.hypertarget_to(node)
         table_type = self.table.get_table_type()
-        table = self.render(table_type + '.tex.jinja',
-                            {'table': self.table, 'labels': labels})
+        table = self.render(
+            table_type + '.tex.jinja', {'table': self.table, 'labels': labels}
+        )
         self.body.append(BLANKLINE)
         self.body.append(table)
         self.body.append(CR)
@@ -1130,15 +1250,19 @@ class LaTeXTranslator(SphinxTranslator):
                 # insert suitable strut for equalizing row heights in given multirow
                 self.body.append(r'\sphinxtablestrut{%d}' % cell.cell_id)
             else:  # use \multicolumn for wide multirow cell
-                self.body.append(r'\multicolumn{%d}{%sl%s}{\sphinxtablestrut{%d}}' %
-                                 (cell.width, _colsep, _colsep, cell.cell_id))
+                self.body.append(
+                    r'\multicolumn{%d}{%sl%s}{\sphinxtablestrut{%d}}'
+                    % (cell.width, _colsep, _colsep, cell.cell_id)
+                )
 
     def depart_row(self, node: Element) -> None:
         assert self.table is not None
         self.body.append(r'\\' + CR)
         cells = [self.table.cell(self.table.row, i) for i in range(self.table.colcount)]
-        underlined = [cell.row + cell.height == self.table.row + 1  # type: ignore[union-attr]
-                      for cell in cells]
+        underlined = [
+            cell.row + cell.height == self.table.row + 1  # type: ignore[union-attr]
+            for cell in cells
+        ]
         if all(underlined):
             self.body.append(r'\sphinxhline')
         else:
@@ -1175,28 +1299,46 @@ class LaTeXTranslator(SphinxTranslator):
         if cell.width > 1:
             if self.config.latex_use_latex_multicolumn:
                 if self.table.col == 0:
-                    self.body.append(r'\multicolumn{%d}{%sl%s}{%%' %
-                                     (cell.width, _colsep, _colsep) + CR)
+                    self.body.append(
+                        r'\multicolumn{%d}{%sl%s}{%%' % (cell.width, _colsep, _colsep)
+                        + CR
+                    )
                 else:
-                    self.body.append(r'\multicolumn{%d}{l%s}{%%' % (cell.width, _colsep) + CR)
+                    self.body.append(
+                        r'\multicolumn{%d}{l%s}{%%' % (cell.width, _colsep) + CR
+                    )
                 context = '}%' + CR
             else:
                 self.body.append(r'\sphinxstartmulticolumn{%d}%%' % cell.width + CR)
                 context = r'\sphinxstopmulticolumn' + CR
         if cell.height > 1:
             # \sphinxmultirow 2nd arg "cell_id" will serve as id for LaTeX macros as well
-            self.body.append(r'\sphinxmultirow{%d}{%d}{%%' % (cell.height, cell.cell_id) + CR)
+            self.body.append(
+                r'\sphinxmultirow{%d}{%d}{%%' % (cell.height, cell.cell_id) + CR
+            )
             context = '}%' + CR + context
         if cell.width > 1 or cell.height > 1:
-            self.body.append(r'\begin{varwidth}[t]{\sphinxcolwidth{%d}{%d}}'
-                             % (cell.width, self.table.colcount) + CR)
-            context = (r'\par' + CR + r'\vskip-\baselineskip'
-                       r'\vbox{\hbox{\strut}}\end{varwidth}%' + CR + context)
+            self.body.append(
+                r'\begin{varwidth}[t]{\sphinxcolwidth{%d}{%d}}'
+                % (cell.width, self.table.colcount)
+                + CR
+            )
+            context = (
+                r'\par' + CR + r'\vskip-\baselineskip'
+                r'\vbox{\hbox{\strut}}\end{varwidth}%' + CR + context
+            )
             self.needs_linetrimming = 1
         if len(list(node.findall(nodes.paragraph))) >= 2:
             self.table.has_oldproblematic = True
-        if isinstance(node.parent.parent, nodes.thead) or (cell.col in self.table.stubs):
-            if len(node) == 1 and isinstance(node[0], nodes.paragraph) and node.astext() == '':
+        if (
+            isinstance(node.parent.parent, nodes.thead)
+            or (cell.col in self.table.stubs)
+        ):  # fmt: skip
+            if (
+                len(node) == 1
+                and isinstance(node[0], nodes.paragraph)
+                and node.astext() == ''
+            ):
                 pass
             else:
                 self.body.append(r'\sphinxstyletheadfamily ')
@@ -1235,8 +1377,10 @@ class LaTeXTranslator(SphinxTranslator):
                 self.body.append(r'\sphinxtablestrut{%d}' % nextcell.cell_id)
             else:
                 # use \multicolumn for not first row of wide multirow cell
-                self.body.append(r'\multicolumn{%d}{l%s}{\sphinxtablestrut{%d}}' %
-                                 (nextcell.width, _colsep, nextcell.cell_id))
+                self.body.append(
+                    r'\multicolumn{%d}{l%s}{\sphinxtablestrut{%d}}'
+                    % (nextcell.width, _colsep, nextcell.cell_id)
+                )
             self.table.col += nextcell.width
 
     def visit_acks(self, node: Element) -> None:
@@ -1276,15 +1420,18 @@ class LaTeXTranslator(SphinxTranslator):
             else:
                 return get_nested_level(node.parent)
 
-        enum = "enum%s" % toRoman(get_nested_level(node)).lower()
-        enumnext = "enum%s" % toRoman(get_nested_level(node) + 1).lower()
+        enum = 'enum%s' % toRoman(get_nested_level(node)).lower()
+        enumnext = 'enum%s' % toRoman(get_nested_level(node) + 1).lower()
         style = ENUMERATE_LIST_STYLE.get(get_enumtype(node))
         prefix = node.get('prefix', '')
         suffix = node.get('suffix', '.')
 
         self.body.append(r'\begin{enumerate}' + CR)
-        self.body.append(r'\sphinxsetlistlabels{%s}{%s}{%s}{%s}{%s}%%' %
-                         (style, enum, enumnext, prefix, suffix) + CR)
+        self.body.append(
+            r'\sphinxsetlistlabels{%s}{%s}{%s}{%s}{%s}%%'
+            % (style, enum, enumnext, prefix, suffix)
+            + CR
+        )
         if 'start' in node:
             self.body.append(r'\setcounter{%s}{%d}' % (enum, node['start'] - 1) + CR)
         if self.table:
@@ -1364,9 +1511,12 @@ class LaTeXTranslator(SphinxTranslator):
 
     def visit_paragraph(self, node: Element) -> None:
         index = node.parent.index(node)
-        if (index > 0 and isinstance(node.parent, nodes.compound) and
-                not isinstance(node.parent[index - 1], nodes.paragraph) and
-                not isinstance(node.parent[index - 1], nodes.compound)):
+        if (
+            index > 0
+            and isinstance(node.parent, nodes.compound)
+            and not isinstance(node.parent[index - 1], nodes.paragraph)
+            and 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):
@@ -1396,8 +1546,10 @@ class LaTeXTranslator(SphinxTranslator):
         if self.compact_list > 1:
             self.body.append(r'\setlength{\multicolsep}{0pt}' + CR)
         self.body.append(r'\begin{multicols}{' + ncolumns + r'}\raggedright' + CR)
-        self.body.append(r'\begin{itemize}\setlength{\itemsep}{0pt}'
-                         r'\setlength{\parskip}{0pt}' + CR)
+        self.body.append(
+            r'\begin{itemize}\setlength{\itemsep}{0pt}'
+            r'\setlength{\parskip}{0pt}' + CR
+        )
         if self.table:
             self.table.has_problematic = True
 
@@ -1454,8 +1606,9 @@ class LaTeXTranslator(SphinxTranslator):
             if not include_graphics_options:
                 # if no "width" nor "height", \sphinxincludegraphics will fit
                 # to the available text width if oversized after rescaling.
-                include_graphics_options.append('scale=%s'
-                                                % (float(node['scale']) / 100.0))
+                include_graphics_options.append(
+                    'scale=%s' % (float(node['scale']) / 100.0)
+                )
         if 'align' in node:
             align_prepost = {
                 # By default latex aligns the top of an image.
@@ -1500,9 +1653,9 @@ class LaTeXTranslator(SphinxTranslator):
         if self.in_title and base:
             # Lowercase tokens forcely because some fncychap themes capitalize
             # the options of \sphinxincludegraphics unexpectedly (ex. WIDTH=...).
-            cmd = fr'\lowercase{{\sphinxincludegraphics{options}}}{{{{{base}}}{ext}}}'
+            cmd = rf'\lowercase{{\sphinxincludegraphics{options}}}{{{{{base}}}{ext}}}'
         else:
-            cmd = fr'\sphinxincludegraphics{options}{{{{{base}}}{ext}}}'
+            cmd = rf'\sphinxincludegraphics{options}{{{{{base}}}{ext}}}'
         # escape filepath for includegraphics, https://tex.stackexchange.com/a/202714/41112
         if '#' in base:
             cmd = r'{\catcode`\#=12' + cmd + '}'
@@ -1515,7 +1668,7 @@ class LaTeXTranslator(SphinxTranslator):
     def visit_figure(self, node: Element) -> None:
         align = self.elements['figure_align']
         if self.no_latex_floats:
-            align = "H"
+            align = 'H'
         if self.table:
             # Blank line is needed if text precedes
             self.body.append(BLANKLINE)
@@ -1540,13 +1693,18 @@ class LaTeXTranslator(SphinxTranslator):
             # Insert a blank line to prevent an infinite loop
             # https://github.com/sphinx-doc/sphinx/issues/7059
             self.body.append(BLANKLINE)
-            self.body.append(r'\begin{wrapfigure}{%s}{%s}' %
-                             ('r' if node['align'] == 'right' else 'l', length or '0pt') + CR)
+            self.body.append(
+                r'\begin{wrapfigure}{%s}{%s}'
+                % ('r' if node['align'] == 'right' else 'l', length or '0pt')
+                + CR
+            )
             self.body.append(r'\centering')
-            self.context.append(r'\end{wrapfigure}' +
-                                BLANKLINE +
-                                r'\mbox{}\par\vskip-\dimexpr\baselineskip+\parskip\relax' +
-                                CR)  # avoid disappearance if no text next issues/11079
+            self.context.append(
+                r'\end{wrapfigure}'
+                + BLANKLINE
+                + r'\mbox{}\par\vskip-\dimexpr\baselineskip+\parskip\relax'
+                + CR
+            )  # avoid disappearance if no text next issues/11079
         elif self.in_minipage:
             self.body.append(CR + r'\begin{center}')
             self.context.append(r'\end{center}' + CR)
@@ -1596,8 +1754,9 @@ class LaTeXTranslator(SphinxTranslator):
 
     def _visit_named_admonition(self, node: Element) -> None:
         label = admonitionlabels[node.tagname]
-        self.body.append(CR + r'\begin{sphinxadmonition}{%s}{%s:}' %
-                         (node.tagname, label))
+        self.body.append(
+            CR + r'\begin{sphinxadmonition}{%s}{%s:}' % (node.tagname, label)
+        )
         self.no_latex_floats += 1
         if self.table:
             self.table.has_problematic = True
@@ -1657,10 +1816,13 @@ class LaTeXTranslator(SphinxTranslator):
         while isinstance(next_node, nodes.target):
             next_node = next_node.next_node(ascend=True)
 
-        domain = cast(StandardDomain, self.builder.env.get_domain('std'))
+        domain = self.builder.env.domains.standard_domain
         if isinstance(next_node, HYPERLINK_SUPPORT_NODES):
             return
-        if domain.get_enumerable_node_type(next_node) and domain.get_numfig_title(next_node):
+        if (
+            domain.get_enumerable_node_type(next_node)
+            and domain.get_numfig_title(next_node)
+        ):  # fmt: skip
             return
 
         if 'refuri' in node:
@@ -1669,7 +1831,10 @@ class LaTeXTranslator(SphinxTranslator):
             return
         if node.get('refid'):
             prev_node = get_prev_node(node)
-            if isinstance(prev_node, nodes.reference) and node['refid'] == prev_node['refid']:
+            if (
+                isinstance(prev_node, nodes.reference)
+                and node['refid'] == prev_node['refid']
+            ):
                 # a target for a hyperlink reference having alias
                 pass
             else:
@@ -1738,27 +1903,30 @@ class LaTeXTranslator(SphinxTranslator):
                     try:
                         p1, p2 = parts
                         P1, P2 = styled
-                        self.body.append(fr'\index{{{p1}@{P1}!{p2}@{P2}{m}}}')
+                        self.body.append(rf'\index{{{p1}@{P1}!{p2}@{P2}{m}}}')
                     except ValueError:
-                        p, = parts
-                        P, = styled
-                        self.body.append(fr'\index{{{p}@{P}{m}}}')
+                        (p,) = parts
+                        (P,) = styled
+                        self.body.append(rf'\index{{{p}@{P}{m}}}')
                 elif type == 'pair':
                     p1, p2 = parts
                     P1, P2 = styled
-                    self.body.append(fr'\index{{{p1}@{P1}!{p2}@{P2}{m}}}'
-                                     fr'\index{{{p2}@{P2}!{p1}@{P1}{m}}}')
+                    self.body.append(
+                        rf'\index{{{p1}@{P1}!{p2}@{P2}{m}}}'
+                        rf'\index{{{p2}@{P2}!{p1}@{P1}{m}}}'
+                    )
                 elif type == 'triple':
                     p1, p2, p3 = parts
                     P1, P2, P3 = styled
                     self.body.append(
-                        fr'\index{{{p1}@{P1}!{p2} {p3}@{P2} {P3}{m}}}'
-                        fr'\index{{{p2}@{P2}!{p3}, {p1}@{P3}, {P1}{m}}}'
-                        fr'\index{{{p3}@{P3}!{p1} {p2}@{P1} {P2}{m}}}')
+                        rf'\index{{{p1}@{P1}!{p2} {p3}@{P2} {P3}{m}}}'
+                        rf'\index{{{p2}@{P2}!{p3}, {p1}@{P3}, {P1}{m}}}'
+                        rf'\index{{{p3}@{P3}!{p1} {p2}@{P1} {P2}{m}}}'
+                    )
                 elif type in {'see', 'seealso'}:
                     p1, p2 = parts
                     P1, _P2 = styled
-                    self.body.append(fr'\index{{{p1}@{P1}|see{{{p2}}}}}')
+                    self.body.append(rf'\index{{{p1}@{P1}|see{{{p2}}}}}')
                 else:
                     logger.warning(__('unknown index entry type %s found'), type)
             except ValueError as err:
@@ -1793,8 +1961,7 @@ class LaTeXTranslator(SphinxTranslator):
             id = self.curfilestack[-1] + ':' + uri[1:]
             self.body.append(self.hyperlink(id))
             self.body.append(r'\sphinxsamedocref{')
-            if self.config.latex_show_pagerefs and not \
-                    self.in_production_list:
+            if self.config.latex_show_pagerefs and not self.in_production_list:
                 self.context.append('}}} (%s)' % self.hyperpageref(id))
             else:
                 self.context.append('}}}')
@@ -1808,9 +1975,11 @@ class LaTeXTranslator(SphinxTranslator):
                 # reference to a label
                 id = uri[1:].replace('#', ':')
             self.body.append(self.hyperlink(id))
-            if (len(node) and
-                    isinstance(node[0], nodes.Element) and
-                    'std-term' in node[0].get('classes', [])):
+            if (
+                len(node)
+                and isinstance(node[0], nodes.Element)
+                and 'std-term' in node[0].get('classes', [])
+            ):
                 # don't add a pageref for glossary terms
                 self.context.append('}}}')
                 # mark up as termreference
@@ -1846,13 +2015,17 @@ class LaTeXTranslator(SphinxTranslator):
         title = self.escape(node.get('title', '%s')).replace(r'\%s', '%s')
         if r'\{name\}' in title or r'\{number\}' in title:
             # new style format (cf. "Fig.%{number}")
-            title = title.replace(r'\{name\}', '{name}').replace(r'\{number\}', '{number}')
-            text = escape_abbr(title).format(name=r'\nameref{%s}' % self.idescape(id),
-                                             number=r'\ref{%s}' % self.idescape(id))
+            title = title.replace(r'\{name\}', '{name}').replace(
+                r'\{number\}', '{number}'
+            )
+            text = escape_abbr(title).format(
+                name=r'\nameref{%s}' % self.idescape(id),
+                number=r'\ref{%s}' % self.idescape(id),
+            )
         else:
             # old style format (cf. "Fig.%{number}")
             text = escape_abbr(title) % (r'\ref{%s}' % self.idescape(id))
-        hyperref = fr'\hyperref[{self.idescape(id)}]{{{text}}}'
+        hyperref = rf'\hyperref[{self.idescape(id)}]{{{text}}}'
         self.body.append(hyperref)
 
         raise nodes.SkipNode
@@ -1926,16 +2099,19 @@ class LaTeXTranslator(SphinxTranslator):
             # adjust max width of citation labels not to break the layout
             longest_label = longest_label[:MAX_CITATION_LABEL_LENGTH]
 
-        self.body.append(CR + r'\begin{sphinxthebibliography}{%s}' %
-                         self.encode(longest_label) + CR)
+        self.body.append(
+            CR + r'\begin{sphinxthebibliography}{%s}' % self.encode(longest_label) + CR
+        )
 
     def depart_thebibliography(self, node: Element) -> None:
         self.body.append(r'\end{sphinxthebibliography}' + CR)
 
     def visit_citation(self, node: Element) -> None:
         label = cast(nodes.label, node[0])
-        self.body.append(fr'\bibitem[{self.encode(label.astext())}]'
-                         fr'{{{node["docname"]}:{node["ids"][0]}}}')
+        self.body.append(
+            rf'\bibitem[{self.encode(label.astext())}]'
+            rf'{{{node["docname"]}:{node["ids"][0]}}}'
+        )
 
     def depart_citation(self, node: Element) -> None:
         pass
@@ -1944,7 +2120,7 @@ class LaTeXTranslator(SphinxTranslator):
         if self.in_title:
             pass
         else:
-            self.body.append(fr'\sphinxcite{{{node["docname"]}:{node["refname"]}}}')
+            self.body.append(rf'\sphinxcite{{{node["docname"]}:{node["refname"]}}}')
             raise nodes.SkipNode
 
     def depart_citation_reference(self, node: Element) -> None:
@@ -1957,17 +2133,18 @@ class LaTeXTranslator(SphinxTranslator):
         elif 'kbd' in node['classes']:
             self.body.append(r'\sphinxkeyboard{\sphinxupquote{')
             return
-        lang = node.get("language", None)
+        lang = node.get('language', None)
         if 'code' not in node['classes'] or not lang:
             self.body.append(r'\sphinxcode{\sphinxupquote{')
             return
 
         opts = self.config.highlight_options.get(lang, {})
         hlcode = self.highlighter.highlight_block(
-            node.astext(), lang, opts=opts, location=node, nowrap=True)
-        self.body.append(r'\sphinxcode{\sphinxupquote{%' + CR
-                         + hlcode.rstrip() + '%' + CR
-                         + '}}')
+            node.astext(), lang, opts=opts, location=node, nowrap=True
+        )
+        self.body.append(
+            r'\sphinxcode{\sphinxupquote{%' + CR + hlcode.rstrip() + '%' + CR + '}}'
+        )
         raise nodes.SkipNode
 
     def depart_literal(self, node: Element) -> None:
@@ -2018,23 +2195,26 @@ class LaTeXTranslator(SphinxTranslator):
             opts = self.config.highlight_options.get(lang, {})
 
             hlcode = self.highlighter.highlight_block(
-                node.rawsource, lang, opts=opts, linenos=linenos,
-                location=node, **highlight_args,
+                node.rawsource,
+                lang,
+                opts=opts,
+                linenos=linenos,
+                location=node,
+                **highlight_args,
             )
             if self.in_footnote:
                 self.body.append(CR + r'\sphinxSetupCodeBlockInFootnote')
-                hlcode = hlcode.replace(r'\begin{Verbatim}',
-                                        r'\begin{sphinxVerbatim}')
+                hlcode = hlcode.replace(r'\begin{Verbatim}', r'\begin{sphinxVerbatim}')
             # if in table raise verbatim flag to avoid "tabulary" environment
             # and opt for sphinxVerbatimintable to handle caption & long lines
             elif self.table:
                 self.table.has_problematic = True
                 self.table.has_verbatim = True
-                hlcode = hlcode.replace(r'\begin{Verbatim}',
-                                        r'\begin{sphinxVerbatimintable}')
+                hlcode = hlcode.replace(
+                    r'\begin{Verbatim}', r'\begin{sphinxVerbatimintable}'
+                )
             else:
-                hlcode = hlcode.replace(r'\begin{Verbatim}',
-                                        r'\begin{sphinxVerbatim}')
+                hlcode = hlcode.replace(r'\begin{Verbatim}', r'\begin{sphinxVerbatim}')
             # get consistent trailer
             hlcode = hlcode.rstrip()[:-14]  # strip \end{Verbatim}
             if self.table and not self.in_footnote:
@@ -2053,6 +2233,7 @@ class LaTeXTranslator(SphinxTranslator):
     def depart_literal_block(self, node: Element) -> None:
         self.body.append(CR + r'\end{sphinxalltt}' + CR)
         self.in_parsed_literal -= 1
+
     visit_doctest_block = visit_literal_block
     depart_doctest_block = depart_literal_block
 
@@ -2173,8 +2354,8 @@ class LaTeXTranslator(SphinxTranslator):
             self.body.append(r'\sphinxaccelerator{')
             self.context.append('}')
         elif classes and not self.in_title:
-            self.body.append(r'\DUrole{%s}{' % ','.join(classes))
-            self.context.append('}')
+            self.body.append(r'\DUrole{' + r'}{\DUrole{'.join(classes) + '}{')
+            self.context.append('}' * len(classes))
         else:
             self.context.append('')
 
@@ -2235,9 +2416,12 @@ class LaTeXTranslator(SphinxTranslator):
         #       this must be checked against hyperref package exact dealings
         #       mainly, %, #, {, } and \ need escaping via a \ escape
         # in \href, the tilde is allowed and must be represented literally
-        return self.encode(text).replace(r'\textasciitilde{}', '~').\
-            replace(r'\sphinxhyphen{}', '-').\
-            replace(r'\textquotesingle{}', "'")
+        return (
+            self.encode(text)
+            .replace(r'\textasciitilde{}', '~')
+            .replace(r'\sphinxhyphen{}', '-')
+            .replace(r'\textquotesingle{}', "'")
+        )
 
     def visit_Text(self, node: Text) -> None:
         text = self.encode(node.astext())
@@ -2278,8 +2462,10 @@ class LaTeXTranslator(SphinxTranslator):
             self.body.append(node.astext())
         else:
             from sphinx.util.math import wrap_displaymath
-            self.body.append(wrap_displaymath(node.astext(), label,
-                                              self.config.math_number_all))
+
+            self.body.append(
+                wrap_displaymath(node.astext(), label, self.config.math_number_all)
+            )
         raise nodes.SkipNode
 
     def visit_math_reference(self, node: Element) -> None:
@@ -2290,8 +2476,7 @@ class LaTeXTranslator(SphinxTranslator):
                 ref = r'\ref{%s}' % label
                 self.body.append(eqref_format.format(number=ref))
             except KeyError as exc:
-                logger.warning(__('Invalid math_eqref_format: %r'), exc,
-                               location=node)
+                logger.warning(__('Invalid math_eqref_format: %r'), exc, location=node)
                 self.body.append(r'\eqref{%s}' % label)
         else:
             self.body.append(r'\eqref{%s}' % label)
@@ -2303,5 +2488,7 @@ 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
-    HYPERLINK_SUPPORT_NODES, captioned_literal_block, footnotetext,
+    HYPERLINK_SUPPORT_NODES,
+    captioned_literal_block,
+    footnotetext,
 )