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

sphinx/builders/latex/__init__.py

@@ -12,7 +12,11 @@ from docutils.frontend import OptionParser
 import sphinx.builders.latex.nodes  # NoQA: F401,E501  # Workaround: import this before writer to avoid ImportError
 from sphinx import addnodes, highlighting, package_dir
 from sphinx.builders import Builder
-from sphinx.builders.latex.constants import ADDITIONAL_SETTINGS, DEFAULT_SETTINGS, SHORTHANDOFF
+from sphinx.builders.latex.constants import (
+    ADDITIONAL_SETTINGS,
+    DEFAULT_SETTINGS,
+    SHORTHANDOFF,
+)
 from sphinx.builders.latex.theming import Theme, ThemeFactory
 from sphinx.builders.latex.util import ExtBabel
 from sphinx.config import ENUM, Config
@@ -34,7 +38,7 @@ from sphinx.writers.latex import LaTeXTranslator, LaTeXWriter
 from docutils import nodes  # isort:skip
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
+    from collections.abc import Iterable, Set
 
     from docutils.nodes import Node
 
@@ -96,11 +100,9 @@ XINDY_LANG_OPTIONS = {
     'el': '-L greek -C utf8 ',
     # FIXME, not compatible with [:2] slice but does Sphinx support Greek ?
     'el-polyton': '-L greek-polytonic -C utf8 ',
-}
+}  # fmt: skip
 
-XINDY_CYRILLIC_SCRIPTS = [
-    'be', 'bg', 'mk', 'mn', 'ru', 'sr', 'sh', 'uk',
-]
+XINDY_CYRILLIC_SCRIPTS = ['be', 'bg', 'mk', 'mn', 'ru', 'sr', 'sh', 'uk']
 
 logger = logging.getLogger(__name__)
 
@@ -114,9 +116,11 @@ class LaTeXBuilder(Builder):
     format = 'latex'
     epilog = __('The LaTeX files are in %(outdir)s.')
     if os.name == 'posix':
-        epilog += __("\nRun 'make' in that directory to run these through "
-                     "(pdf)latex\n"
-                     "(use `make latexpdf' here to do that automatically).")
+        epilog += __(
+            "\nRun 'make' in that directory to run these through "
+            '(pdf)latex\n'
+            "(use `make latexpdf' here to do that automatically)."
+        )
 
     supported_image_types = ['application/pdf', 'image/png', 'image/jpeg']
     supported_remote_images = False
@@ -149,20 +153,28 @@ class LaTeXBuilder(Builder):
     def init_document_data(self) -> None:
         preliminary_document_data = [list(x) for x in self.config.latex_documents]
         if not preliminary_document_data:
-            logger.warning(__('no "latex_documents" config value found; no documents '
-                              'will be written'))
+            logger.warning(
+                __(
+                    'no "latex_documents" config value found; no documents '
+                    'will be written'
+                )
+            )
             return
         # assign subdirs to titles
         self.titles: list[tuple[str, str]] = []
         for entry in preliminary_document_data:
             docname = entry[0]
             if docname not in self.env.all_docs:
-                logger.warning(__('"latex_documents" config value references unknown '
-                                  'document %s'), docname)
+                logger.warning(
+                    __(
+                        '"latex_documents" config value references unknown '
+                        'document %s'
+                    ),
+                    docname,
+                )
                 continue
             self.document_data.append(entry)  # type: ignore[arg-type]
-            if docname.endswith(SEP + 'index'):
-                docname = docname[:-5]
+            docname = docname.removesuffix(SEP + 'index')
             self.titles.append((docname, entry[2]))
 
     def init_context(self) -> None:
@@ -186,8 +198,8 @@ class LaTeXBuilder(Builder):
         if self.config.today:
             self.context['date'] = self.config.today
         else:
-            self.context['date'] = format_date(self.config.today_fmt or _('%b %d, %Y'),
-                                               language=self.config.language)
+            today_fmt = self.config.today_fmt or _('%b %d, %Y')
+            self.context['date'] = format_date(today_fmt, language=self.config.language)
 
         if self.config.latex_logo:
             self.context['logofilename'] = path.basename(self.config.latex_logo)
@@ -210,25 +222,31 @@ class LaTeXBuilder(Builder):
         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
+            )
 
     def init_multilingual(self) -> None:
         if self.context['latex_engine'] == 'pdflatex':
             if not self.babel.uses_cyrillic():
                 if 'X2' in self.context['fontenc']:
-                    self.context['substitutefont'] = ('\\usepackage'
-                                                      '{sphinxpackagesubstitutefont}')
-                    self.context['textcyrillic'] = ('\\usepackage[Xtwo]'
-                                                    '{sphinxpackagecyrillic}')
+                    self.context['substitutefont'] = (
+                        '\\usepackage{sphinxpackagesubstitutefont}'
+                    )
+                    self.context['textcyrillic'] = (
+                        '\\usepackage[Xtwo]{sphinxpackagecyrillic}'
+                    )
                 elif 'T2A' in self.context['fontenc']:
-                    self.context['substitutefont'] = ('\\usepackage'
-                                                      '{sphinxpackagesubstitutefont}')
-                    self.context['textcyrillic'] = ('\\usepackage[TtwoA]'
-                                                    '{sphinxpackagecyrillic}')
+                    self.context['substitutefont'] = (
+                        '\\usepackage{sphinxpackagesubstitutefont}'
+                    )
+                    self.context['textcyrillic'] = (
+                        '\\usepackage[TtwoA]{sphinxpackagecyrillic}'
+                    )
             if 'LGR' in self.context['fontenc']:
-                self.context['substitutefont'] = ('\\usepackage'
-                                                  '{sphinxpackagesubstitutefont}')
+                self.context['substitutefont'] = (
+                    '\\usepackage{sphinxpackagesubstitutefont}'
+                )
             else:
                 self.context['textgreek'] = ''
             if self.context['substitutefont'] == '':
@@ -242,13 +260,18 @@ class LaTeXBuilder(Builder):
             self.context['shorthandoff'] = SHORTHANDOFF
 
             # Times fonts don't work with Cyrillic languages
-            if self.babel.uses_cyrillic() and 'fontpkg' not in self.config.latex_elements:
+            if (
+                self.babel.uses_cyrillic()
+                and 'fontpkg' not in self.config.latex_elements
+            ):
                 self.context['fontpkg'] = ''
         elif self.context['polyglossia']:
             self.context['classoptions'] += ',' + self.babel.get_language()
             options = self.babel.get_mainlanguage_options()
             if options:
-                language = fr'\setmainlanguage[{options}]{{{self.babel.get_language()}}}'
+                language = (
+                    rf'\setmainlanguage[{options}]{{{self.babel.get_language()}}}'
+                )
             else:
                 language = r'\setmainlanguage{%s}' % self.babel.get_language()
 
@@ -257,20 +280,28 @@ class LaTeXBuilder(Builder):
     def write_stylesheet(self) -> None:
         highlighter = highlighting.PygmentsBridge('latex', self.config.pygments_style)
         stylesheet = path.join(self.outdir, 'sphinxhighlight.sty')
-        with open(stylesheet, 'w', encoding="utf-8") as f:
+        with open(stylesheet, 'w', encoding='utf-8') as f:
             f.write('\\NeedsTeXFormat{LaTeX2e}[1995/12/01]\n')
-            f.write('\\ProvidesPackage{sphinxhighlight}'
-                    '[2022/06/30 stylesheet for highlighting with pygments]\n')
-            f.write('% Its contents depend on pygments_style configuration variable.\n\n')
+            f.write(
+                '\\ProvidesPackage{sphinxhighlight}'
+                '[2022/06/30 stylesheet for highlighting with pygments]\n'
+            )
+            f.write(
+                '% Its contents depend on pygments_style configuration variable.\n\n'
+            )
             f.write(highlighter.get_stylesheet())
 
+    def prepare_writing(self, docnames: Set[str]) -> None:
+        self.init_document_data()
+        self.write_stylesheet()
+
     def copy_assets(self) -> None:
         self.copy_support_files()
 
         if self.config.latex_additional_files:
             self.copy_latex_additional_files()
 
-    def write(self, *ignored: Any) -> None:
+    def write_documents(self, _docnames: Set[str]) -> None:
         docwriter = LaTeXWriter(self)
         with warnings.catch_warnings():
             warnings.filterwarnings('ignore', category=DeprecationWarning)
@@ -279,11 +310,8 @@ class LaTeXBuilder(Builder):
             docsettings: Any = OptionParser(
                 defaults=self.env.settings,
                 components=(docwriter,),
-                read_config_files=True).get_default_values()
-
-        self.init_document_data()
-        self.write_stylesheet()
-        self.copy_assets()
+                read_config_files=True,
+            ).get_default_values()
 
         for entry in self.document_data:
             docname, targetname, title, author, themename = entry[:5]
@@ -291,9 +319,12 @@ class LaTeXBuilder(Builder):
             toctree_only = False
             if len(entry) > 5:
                 toctree_only = entry[5]
-            destination = SphinxFileOutput(destination_path=path.join(self.outdir, targetname),
-                                           encoding='utf-8', overwrite_if_changed=True)
-            with progress_message(__("processing %s") % targetname):
+            destination = SphinxFileOutput(
+                destination_path=path.join(self.outdir, targetname),
+                encoding='utf-8',
+                overwrite_if_changed=True,
+            )
+            with progress_message(__('processing %s') % targetname, nonl=False):
                 doctree = self.env.get_doctree(docname)
                 toctree = next(doctree.findall(addnodes.toctree), None)
                 if toctree and toctree.get('maxdepth') > 0:
@@ -302,8 +333,12 @@ class LaTeXBuilder(Builder):
                     tocdepth = None
 
                 doctree = self.assemble_doctree(
-                    docname, toctree_only,
-                    appendices=(self.config.latex_appendices if theme.name != 'howto' else []))
+                    docname,
+                    toctree_only,
+                    appendices=(
+                        self.config.latex_appendices if theme.name != 'howto' else []
+                    ),
+                )
                 doctree['docclass'] = theme.docclass
                 doctree['contentsname'] = self.get_contentsname(docname)
                 doctree['tocdepth'] = tocdepth
@@ -311,7 +346,7 @@ class LaTeXBuilder(Builder):
                 self.update_doc_context(title, author, theme)
                 self.update_context()
 
-            with progress_message(__("writing")):
+            with progress_message(__('writing')):
                 docsettings._author = author
                 docsettings._title = title
                 docsettings._contentsname = doctree['contentsname']
@@ -341,10 +376,13 @@ class LaTeXBuilder(Builder):
         self.context['wrapperclass'] = theme.wrapperclass
 
     def assemble_doctree(
-        self, indexfile: str, toctree_only: bool, appendices: list[str],
+        self,
+        indexfile: str,
+        toctree_only: bool,
+        appendices: list[str],
     ) -> nodes.document:
         self.docnames = {indexfile, *appendices}
-        logger.info(darkgreen(indexfile) + " ", nonl=True)
+        logger.info(darkgreen(indexfile))
         tree = self.env.get_doctree(indexfile)
         tree['docname'] = indexfile
         if toctree_only:
@@ -352,21 +390,21 @@ class LaTeXBuilder(Builder):
             # fresh document
             new_tree = new_document('<latex output>')
             new_sect = nodes.section()
-            new_sect += nodes.title('<Set title in conf.py>',
-                                    '<Set title in conf.py>')
+            new_sect += nodes.title('<Set title in conf.py>', '<Set title in conf.py>')
             new_tree += new_sect
             for node in tree.findall(addnodes.toctree):
                 new_sect += node
             tree = new_tree
-        largetree = inline_all_toctrees(self, self.docnames, indexfile, tree,
-                                        darkgreen, [indexfile])
+        largetree = inline_all_toctrees(
+            self, self.docnames, indexfile, tree, darkgreen, [indexfile]
+        )
         largetree['docname'] = indexfile
         for docname in appendices:
             appendix = self.env.get_doctree(docname)
             appendix['docname'] = docname
             largetree.append(appendix)
         logger.info('')
-        logger.info(__("resolving references..."))
+        logger.info(__('resolving references...'))
         self.env.resolve_references(largetree, indexfile, self)
         # resolve :ref:s to distant tex files -- we can't add a cross-reference,
         # but append the document name
@@ -397,15 +435,16 @@ class LaTeXBuilder(Builder):
         # configure usage of xindy (impacts Makefile and latexmkrc)
         # FIXME: convert this rather to a confval with suitable default
         #        according to language ? but would require extra documentation
-        xindy_lang_option = XINDY_LANG_OPTIONS.get(self.config.language[:2],
-                                                   '-L general -C utf8 ')
+        xindy_lang_option = XINDY_LANG_OPTIONS.get(
+            self.config.language[:2], '-L general -C utf8 '
+        )
         xindy_cyrillic = self.config.language[:2] in XINDY_CYRILLIC_SCRIPTS
 
         context = {
-            'latex_engine':      self.config.latex_engine,
-            'xindy_use':         self.config.latex_use_xindy,
+            'latex_engine': self.config.latex_engine,
+            'xindy_use': self.config.latex_use_xindy,
             'xindy_lang_option': xindy_lang_option,
-            'xindy_cyrillic':    xindy_cyrillic,
+            'xindy_cyrillic': xindy_cyrillic,
         }
         staticdirname = path.join(package_dir, 'texinputs')
         for filename in os.listdir(staticdirname):
@@ -441,9 +480,14 @@ class LaTeXBuilder(Builder):
     def copy_image_files(self) -> None:
         if self.images:
             stringify_func = ImageAdapter(self.app.env).get_original_image_uri
-            for src in status_iterator(self.images, __('copying images... '), "brown",
-                                       len(self.images), self.app.verbosity,
-                                       stringify_func=stringify_func):
+            for src in status_iterator(
+                self.images,
+                __('copying images... '),
+                'brown',
+                len(self.images),
+                self.app.verbosity,
+                stringify_func=stringify_func,
+            ):
                 dest = self.images[src]
                 try:
                     copyfile(
@@ -452,11 +496,16 @@ class LaTeXBuilder(Builder):
                         force=True,
                     )
                 except Exception as err:
-                    logger.warning(__('cannot copy image file %r: %s'),
-                                   path.join(self.srcdir, src), err)
+                    logger.warning(
+                        __('cannot copy image file %r: %s'),
+                        path.join(self.srcdir, src),
+                        err,
+                    )
         if self.config.latex_logo:
             if not path.isfile(path.join(self.confdir, self.config.latex_logo)):
-                raise SphinxError(__('logo file %r does not exist') % self.config.latex_logo)
+                raise SphinxError(
+                    __('logo file %r does not exist') % self.config.latex_logo
+                )
             source = self.confdir / self.config.latex_logo
             copyfile(
                 source,
@@ -476,7 +525,9 @@ class LaTeXBuilder(Builder):
         if self.context['babel'] or self.context['polyglossia']:
             context['addtocaptions'] = r'\addto\captions%s' % self.babel.get_language()
 
-        filename = path.join(package_dir, 'templates', 'latex', 'sphinxmessages.sty.jinja')
+        filename = path.join(
+            package_dir, 'templates', 'latex', 'sphinxmessages.sty.jinja'
+        )
         copy_asset_file(
             filename,
             self.outdir,
@@ -489,7 +540,7 @@ class LaTeXBuilder(Builder):
 def validate_config_values(app: Sphinx, config: Config) -> None:
     for key in list(config.latex_elements):
         if key not in DEFAULT_SETTINGS:
-            msg = __("Unknown configure key: latex_elements[%r], ignored.")
+            msg = __('Unknown configure key: latex_elements[%r], ignored.')
             logger.warning(msg, key)
             config.latex_elements.pop(key)
 
@@ -497,7 +548,7 @@ def validate_config_values(app: Sphinx, config: Config) -> None:
 def validate_latex_theme_options(app: Sphinx, config: Config) -> None:
     for key in list(config.latex_theme_options):
         if key not in Theme.UPDATABLE_KEYS:
-            msg = __("Unknown theme option: latex_theme_options[%r], ignored.")
+            msg = __('Unknown theme option: latex_theme_options[%r], ignored.')
             logger.warning(msg, key)
             config.latex_theme_options.pop(key)
 
@@ -523,11 +574,9 @@ def default_latex_docclass(config: Config) -> dict[str, str]:
     """Better default latex_docclass settings for specific languages."""
     if config.language == 'ja':
         if config.latex_engine == 'uplatex':
-            return {'manual': 'ujbook',
-                    'howto': 'ujreport'}
+            return {'manual': 'ujbook', 'howto': 'ujreport'}
         else:
-            return {'manual': 'jsbook',
-                    'howto': 'jreport'}
+            return {'manual': 'jsbook', 'howto': 'jreport'}
     else:
         return {}
 
@@ -541,11 +590,15 @@ def default_latex_documents(config: Config) -> list[tuple[str, str, str, str, st
     """Better default latex_documents settings."""
     project = texescape.escape(config.project, config.latex_engine)
     author = texescape.escape(config.author, config.latex_engine)
-    return [(config.root_doc,
-             make_filename_from_project(config.project) + '.tex',
-             texescape.escape_abbr(project),
-             texescape.escape_abbr(author),
-             config.latex_theme)]
+    return [
+        (
+            config.root_doc,
+            make_filename_from_project(config.project) + '.tex',
+            texescape.escape_abbr(project),
+            texescape.escape_abbr(author),
+            config.latex_theme,
+        )
+    ]
 
 
 def setup(app: Sphinx) -> ExtensionMetadata:
@@ -556,15 +609,20 @@ def setup(app: Sphinx) -> ExtensionMetadata:
     app.connect('config-inited', validate_latex_theme_options, priority=800)
     app.connect('builder-inited', install_packages_for_ja)
 
-    app.add_config_value('latex_engine', default_latex_engine, '',
-                         ENUM('pdflatex', 'xelatex', 'lualatex', 'platex', 'uplatex'))
+    app.add_config_value(
+        'latex_engine',
+        default_latex_engine,
+        '',
+        ENUM('pdflatex', 'xelatex', 'lualatex', 'platex', 'uplatex'),
+    )
     app.add_config_value('latex_documents', default_latex_documents, '')
     app.add_config_value('latex_logo', None, '', str)
     app.add_config_value('latex_appendices', [], '')
     app.add_config_value('latex_use_latex_multicolumn', False, '')
     app.add_config_value('latex_use_xindy', default_latex_use_xindy, '', bool)
-    app.add_config_value('latex_toplevel_sectioning', None, '',
-                         ENUM(None, 'part', 'chapter', 'section'))
+    app.add_config_value(
+        'latex_toplevel_sectioning', None, '', ENUM(None, 'part', 'chapter', 'section')
+    )
     app.add_config_value('latex_domain_indices', True, '', types={set, list})
     app.add_config_value('latex_show_urls', 'no', '')
     app.add_config_value('latex_show_pagerefs', False, '')

sphinx/builders/latex/constants.py

@@ -49,7 +49,7 @@ XELATEX_DEFAULT_FONTPKG = r'''
   BoldFont       = *Bold,
   BoldItalicFont = *BoldOblique,
 ]
-\setmonofont{FreeMono}[
+\setmonofont{FreeMono}[Scale=0.9,
   Extension      = .otf,
   UprightFont    = *,
   ItalicFont     = *Oblique,
@@ -58,10 +58,12 @@ XELATEX_DEFAULT_FONTPKG = r'''
 ]
 '''
 
-XELATEX_GREEK_DEFAULT_FONTPKG = (XELATEX_DEFAULT_FONTPKG +
-                                 '\n\\newfontfamily\\greekfont{FreeSerif}' +
-                                 '\n\\newfontfamily\\greekfontsf{FreeSans}' +
-                                 '\n\\newfontfamily\\greekfonttt{FreeMono}')
+XELATEX_GREEK_DEFAULT_FONTPKG = (
+    XELATEX_DEFAULT_FONTPKG
+    + '\n\\newfontfamily\\greekfont{FreeSerif}'
+    + '\n\\newfontfamily\\greekfontsf{FreeSans}'
+    + '\n\\newfontfamily\\greekfonttt{FreeMono}'
+)
 
 LUALATEX_DEFAULT_FONTPKG = XELATEX_DEFAULT_FONTPKG
 
@@ -142,7 +144,6 @@ ADDITIONAL_SETTINGS: dict[Any, dict[str, Any]] = {
         'fontenc':     ('\\usepackage{fontspec}\n'
                         '\\defaultfontfeatures[\\rmfamily,\\sffamily,\\ttfamily]{}'),
         'fontpkg':      XELATEX_DEFAULT_FONTPKG,
-        'fvset':        '\\fvset{fontsize=\\small}',
         'fontsubstitution': '',
         'textgreek':    '',
         'utf8extra':   ('\\catcode`^^^^00a0\\active\\protected\\def^^^^00a0'
@@ -155,7 +156,6 @@ ADDITIONAL_SETTINGS: dict[Any, dict[str, Any]] = {
         'fontenc':     ('\\usepackage{fontspec}\n'
                         '\\defaultfontfeatures[\\rmfamily,\\sffamily,\\ttfamily]{}'),
         'fontpkg':      LUALATEX_DEFAULT_FONTPKG,
-        'fvset':        '\\fvset{fontsize=\\small}',
         'fontsubstitution': '',
         'textgreek':    '',
         'utf8extra':   ('\\catcode`^^^^00a0\\active\\protected\\def^^^^00a0'

sphinx/builders/latex/nodes.py

@@ -15,8 +15,9 @@ class footnotemark(nodes.Inline, nodes.Referential, nodes.TextElement):
     pass
 
 
-class footnotetext(nodes.General, nodes.BackLinkable, nodes.Element,
-                   nodes.Labeled, nodes.Targetable):
+class footnotetext(
+    nodes.General, nodes.BackLinkable, nodes.Element, nodes.Labeled, nodes.Targetable
+):
     r"""A node represents ``\footnotetext``."""
 
 

sphinx/builders/latex/theming.py

@@ -84,11 +84,11 @@ class UserTheme(Theme):
                 value = self.config.get('theme', key)
                 setattr(self, key, value)
             except configparser.NoSectionError as exc:
-                raise ThemeError(__('%r doesn\'t have "theme" setting') %
-                                 filename) from exc
+                msg = __('%r doesn\'t have "theme" setting') % filename
+                raise ThemeError(msg) from exc
             except configparser.NoOptionError as exc:
-                raise ThemeError(__('%r doesn\'t have "%s" setting') %
-                                 (filename, exc.args[0])) from exc
+                msg = __('%r doesn\'t have "%s" setting') % (filename, exc.args[0])
+                raise ThemeError(msg) from exc
 
         for key in self.OPTIONAL_CONFIG_KEYS:
             try:
@@ -103,7 +103,9 @@ class ThemeFactory:
 
     def __init__(self, app: Sphinx) -> None:
         self.themes: dict[str, Theme] = {}
-        self.theme_paths = [path.join(app.srcdir, p) for p in app.config.latex_theme_path]
+        self.theme_paths = [
+            path.join(app.srcdir, p) for p in app.config.latex_theme_path
+        ]
         self.config = app.config
         self.load_builtin_themes(app.config)
 

sphinx/builders/latex/transforms.py

@@ -15,7 +15,6 @@ from sphinx.builders.latex.nodes import (
     math_reference,
     thebibliography,
 )
-from sphinx.domains.citation import CitationDomain
 from sphinx.locale import __
 from sphinx.transforms import SphinxTransform
 from sphinx.transforms.post_transforms import SphinxPostTransform
@@ -90,8 +89,7 @@ class ShowUrlsTransform(SphinxPostTransform):
         for node in list(self.document.findall(nodes.reference)):
             uri = node.get('refuri', '')
             if uri.startswith(URI_SCHEMES):
-                if uri.startswith('mailto:'):
-                    uri = uri[7:]
+                uri = uri.removeprefix('mailto:')
                 if node.astext() != uri:
                     index = node.parent.index(node)
                     docname = self.get_docname_for_node(node)
@@ -102,7 +100,7 @@ class ShowUrlsTransform(SphinxPostTransform):
 
                         self.expanded = True
                     else:  # all other true values (b/w compat)
-                        textnode = nodes.Text(" (%s)" % uri)
+                        textnode = nodes.Text(' (%s)' % uri)
                         node.parent.insert(index + 1, textnode)
 
     def get_docname_for_node(self, node: Node) -> str:
@@ -118,11 +116,11 @@ class ShowUrlsTransform(SphinxPostTransform):
             source = node['source']
         except TypeError:
             raise ValueError(__('Failed to get a docname!')) from None
-        raise ValueError(__('Failed to get a docname '
-                            'for source {source!r}!').format(source=source))
+        msg = __('Failed to get a docname for source %r!') % source
+        raise ValueError(msg)
 
     def create_footnote(
-        self, uri: str, docname: str,
+        self, uri: str, docname: str
     ) -> tuple[nodes.footnote, nodes.footnote_reference]:
         reference = nodes.reference('', nodes.Text(uri), refuri=uri, nolinkurl=True)
         footnote = nodes.footnote(uri, auto=1, docname=docname)
@@ -131,8 +129,9 @@ class ShowUrlsTransform(SphinxPostTransform):
         footnote += nodes.paragraph('', '', reference)
         self.document.note_autofootnote(footnote)
 
-        footnote_ref = nodes.footnote_reference('[#]_', auto=1,
-                                                refid=footnote['ids'][0], docname=docname)
+        footnote_ref = nodes.footnote_reference(
+            '[#]_', auto=1, refid=footnote['ids'][0], docname=docname
+        )
         footnote_ref += nodes.Text('#')
         self.document.note_autofootnote_ref(footnote_ref)
         footnote.add_backref(footnote_ref['ids'][0])
@@ -371,7 +370,9 @@ class LaTeXFootnoteTransform(SphinxPostTransform):
 
 
 class LaTeXFootnoteVisitor(nodes.NodeVisitor):
-    def __init__(self, document: nodes.document, footnotes: list[nodes.footnote]) -> None:
+    def __init__(
+        self, document: nodes.document, footnotes: list[nodes.footnote]
+    ) -> None:
         self.appeared: dict[tuple[str, str], nodes.footnote] = {}
         self.footnotes: list[nodes.footnote] = footnotes
         self.pendings: list[nodes.footnote] = []
@@ -393,7 +394,7 @@ class LaTeXFootnoteVisitor(nodes.NodeVisitor):
         if self.restricted == node:
             self.restricted = None
             pos = node.parent.index(node)
-            for i, footnote, in enumerate(self.pendings):
+            for i, footnote in enumerate(self.pendings):
                 fntext = footnotetext('', *footnote.children, ids=footnote['ids'])
                 node.parent.insert(pos + i + 1, fntext)
             self.pendings = []
@@ -455,7 +456,7 @@ class LaTeXFootnoteVisitor(nodes.NodeVisitor):
         docname = node['docname']
         if (docname, number) in self.appeared:
             footnote = self.appeared[(docname, number)]
-            footnote["referred"] = True
+            footnote['referred'] = True
 
             mark = footnotemark('', number, refid=node['refid'])
             node.replace_self(mark)
@@ -473,7 +474,9 @@ class LaTeXFootnoteVisitor(nodes.NodeVisitor):
             self.appeared[(docname, number)] = footnote
         raise nodes.SkipNode
 
-    def get_footnote_by_reference(self, node: nodes.footnote_reference) -> nodes.footnote:
+    def get_footnote_by_reference(
+        self, node: nodes.footnote_reference
+    ) -> nodes.footnote:
         docname = node['docname']
         for footnote in self.footnotes:
             if docname == footnote['docname'] and footnote['ids'][0] == node['refid']:
@@ -537,13 +540,16 @@ class CitationReferenceTransform(SphinxPostTransform):
     formats = ('latex',)
 
     def run(self, **kwargs: Any) -> None:
-        domain = cast(CitationDomain, self.env.get_domain('citation'))
-        matcher = NodeMatcher(addnodes.pending_xref, refdomain='citation', reftype='ref')
+        domain = self.env.domains.citation_domain
+        matcher = NodeMatcher(
+            addnodes.pending_xref, refdomain='citation', reftype='ref'
+        )
         for node in matcher.findall(self.document):
             docname, labelid, _ = domain.citations.get(node['reftarget'], ('', '', 0))
             if docname:
-                citation_ref = nodes.citation_reference('', '', *node.children,
-                                                        docname=docname, refname=labelid)
+                citation_ref = nodes.citation_reference(
+                    '', '', *node.children, docname=docname, refname=labelid
+                )
                 node.replace_self(citation_ref)
 
 
@@ -558,12 +564,14 @@ class MathReferenceTransform(SphinxPostTransform):
     formats = ('latex',)
 
     def run(self, **kwargs: Any) -> None:
-        equations = self.env.get_domain('math').data['objects']
+        equations = self.env.domains.math_domain.data['objects']
         for node in self.document.findall(addnodes.pending_xref):
             if node['refdomain'] == 'math' and node['reftype'] in ('eq', 'numref'):
                 docname, _ = equations.get(node['reftarget'], (None, None))
                 if docname:
-                    refnode = math_reference('', docname=docname, target=node['reftarget'])
+                    refnode = math_reference(
+                        '', docname=docname, target=node['reftarget']
+                    )
                     node.replace_self(refnode)