Sphinx 7.1.2__py3-none-any.whl → 7.2.0__py3-none-any.whl

sphinx/ext/doctest.py

@@ -11,10 +11,9 @@ import sys
 import time
 from io import StringIO
 from os import path
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Sequence
+from typing import TYPE_CHECKING, Any, Callable
 
 from docutils import nodes
-from docutils.nodes import Element, Node, TextElement
 from docutils.parsers.rst import directives
 from packaging.specifiers import InvalidSpecifier, SpecifierSet
 from packaging.version import Version
@@ -23,13 +22,17 @@ import sphinx
 from sphinx.builders import Builder
 from sphinx.locale import __
 from sphinx.util import logging
-from sphinx.util.console import bold  # type: ignore
+from sphinx.util.console import bold  # type: ignore[attr-defined]
 from sphinx.util.docutils import SphinxDirective
 from sphinx.util.osutil import relpath
-from sphinx.util.typing import OptionSpec
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
+    from docutils.nodes import Element, Node, TextElement
+
     from sphinx.application import Sphinx
+    from sphinx.util.typing import OptionSpec
 
 
 logger = logging.getLogger(__name__)
@@ -236,7 +239,7 @@ class TestCode:
 
 
 class SphinxDocTestRunner(doctest.DocTestRunner):
-    def summarize(self, out: Callable, verbose: bool | None = None,  # type: ignore
+    def summarize(self, out: Callable, verbose: bool | None = None,  # type: ignore[override]
                   ) -> tuple[int, int]:
         string_io = StringIO()
         old_stdout = sys.stdout
@@ -251,7 +254,8 @@ class SphinxDocTestRunner(doctest.DocTestRunner):
     def _DocTestRunner__patched_linecache_getlines(self, filename: str,
                                                    module_globals: Any = None) -> Any:
         # this is overridden from DocTestRunner adding the try-except below
-        m = self._DocTestRunner__LINECACHE_FILENAME_RE.match(filename)  # type: ignore
+        m = self._DocTestRunner__LINECACHE_FILENAME_RE.match(  # type: ignore[attr-defined]
+            filename)
         if m and m.group('name') == self.test.name:
             try:
                 example = self.test.examples[int(m.group('examplenum'))]
@@ -262,7 +266,8 @@ class SphinxDocTestRunner(doctest.DocTestRunner):
                 pass
             else:
                 return example.source.splitlines(True)
-        return self.save_linecache_getlines(filename, module_globals)  # type: ignore
+        return self.save_linecache_getlines(  # type: ignore[attr-defined]
+            filename, module_globals)
 
 
 # the new builder -- use sphinx-build.py -b doctest to run
@@ -284,7 +289,7 @@ class DocTestBuilder(Builder):
         # for doctest examples but unusable for multi-statement code such
         # as setup code -- to be able to use doctest error reporting with
         # that code nevertheless, we monkey-patch the "compile" it uses.
-        doctest.compile = self.compile  # type: ignore
+        doctest.compile = self.compile  # type: ignore[attr-defined]
 
         sys.path[0:0] = self.config.doctest_path
 
@@ -299,7 +304,8 @@ class DocTestBuilder(Builder):
 
         date = time.strftime('%Y-%m-%d %H:%M:%S')
 
-        self.outfile = open(path.join(self.outdir, 'output.txt'), 'w', encoding='utf-8')
+        outpath = self.outdir.joinpath('output.txt')
+        self.outfile = outpath.open('w', encoding='utf-8')  # NoQA: SIM115
         self.outfile.write(('Results of doctest builder run on %s\n'
                             '==================================%s\n') %
                            (date, '=' * len(date)))
@@ -402,8 +408,8 @@ Doctest summary
         self.cleanup_runner = SphinxDocTestRunner(verbose=False,
                                                   optionflags=self.opt)
 
-        self.test_runner._fakeout = self.setup_runner._fakeout  # type: ignore
-        self.cleanup_runner._fakeout = self.setup_runner._fakeout  # type: ignore
+        self.test_runner._fakeout = self.setup_runner._fakeout  # type: ignore[attr-defined]
+        self.cleanup_runner._fakeout = self.setup_runner._fakeout  # type: ignore[attr-defined]
 
         if self.config.doctest_test_doctest_blocks:
             def condition(node: Node) -> bool:
@@ -452,8 +458,11 @@ Doctest summary
         if not groups:
             return
 
-        self._out('\nDocument: %s\n----------%s\n' %
-                  (docname, '-' * len(docname)))
+        show_successes = self.config.doctest_show_successes
+        if show_successes:
+            self._out('\n'
+                      f'Document: {docname}\n'
+                      f'----------{"-" * len(docname)}\n')
         for group in groups.values():
             self.test_group(group)
         # Separately count results from setup code
@@ -461,12 +470,13 @@ Doctest summary
         self.setup_failures += res_f
         self.setup_tries += res_t
         if self.test_runner.tries:
-            res_f, res_t = self.test_runner.summarize(self._out, verbose=True)
+            res_f, res_t = self.test_runner.summarize(
+                self._out, verbose=show_successes)
             self.total_failures += res_f
             self.total_tries += res_t
         if self.cleanup_runner.tries:
-            res_f, res_t = self.cleanup_runner.summarize(self._out,
-                                                         verbose=True)
+            res_f, res_t = self.cleanup_runner.summarize(
+                self._out, verbose=show_successes)
             self.cleanup_failures += res_f
             self.cleanup_tries += res_t
 
@@ -526,7 +536,7 @@ Doctest summary
                 # disable <BLANKLINE> processing as it is not needed
                 options[doctest.DONT_ACCEPT_BLANKLINE] = True
                 # find out if we're testing an exception
-                m = parser._EXCEPTION_RE.match(output)  # type: ignore
+                m = parser._EXCEPTION_RE.match(output)  # type: ignore[attr-defined]
                 if m:
                     exc_msg = m.group('msg')
                 else:
@@ -553,6 +563,7 @@ def setup(app: Sphinx) -> dict[str, Any]:
     app.add_directive('testoutput', TestoutputDirective)
     app.add_builder(DocTestBuilder)
     # this config value adds to sys.path
+    app.add_config_value('doctest_show_successes', True, False, (bool,))
     app.add_config_value('doctest_path', [], False)
     app.add_config_value('doctest_test_doctest_blocks', 'default', False)
     app.add_config_value('doctest_global_setup', '', False)

sphinx/ext/duration.py

@@ -1,20 +1,22 @@
-"""Measure durations of Sphinx processing."""
+"""Measure document reading durations."""
 
 from __future__ import annotations
 
-from datetime import datetime, timedelta
+import time
 from itertools import islice
 from operator import itemgetter
-from typing import Any, cast
-
-from docutils import nodes
+from typing import TYPE_CHECKING, cast
 
 import sphinx
-from sphinx.application import Sphinx
 from sphinx.domains import Domain
 from sphinx.locale import __
 from sphinx.util import logging
 
+if TYPE_CHECKING:
+    from docutils import nodes
+
+    from sphinx.application import Sphinx
+
 logger = logging.getLogger(__name__)
 
 
@@ -23,10 +25,10 @@ class DurationDomain(Domain):
     name = 'duration'
 
     @property
-    def reading_durations(self) -> dict[str, timedelta]:
+    def reading_durations(self) -> dict[str, float]:
         return self.data.setdefault('reading_durations', {})
 
-    def note_reading_duration(self, duration: timedelta) -> None:
+    def note_reading_duration(self, duration: float) -> None:
         self.reading_durations[self.env.docname] = duration
 
     def clear(self) -> None:
@@ -35,7 +37,7 @@ class DurationDomain(Domain):
     def clear_doc(self, docname: str) -> None:
         self.reading_durations.pop(docname, None)
 
-    def merge_domaindata(self, docnames: list[str], otherdata: dict[str, timedelta]) -> None:
+    def merge_domaindata(self, docnames: list[str], otherdata: dict[str, float]) -> None:
         for docname, duration in otherdata.items():
             if docname in docnames:
                 self.reading_durations[docname] = duration
@@ -44,7 +46,7 @@ class DurationDomain(Domain):
 def on_builder_inited(app: Sphinx) -> None:
     """Initialize DurationDomain on bootstrap.
 
-    This clears results of last build.
+    This clears the results of the last build.
     """
     domain = cast(DurationDomain, app.env.get_domain('duration'))
     domain.clear()
@@ -52,31 +54,31 @@ def on_builder_inited(app: Sphinx) -> None:
 
 def on_source_read(app: Sphinx, docname: str, content: list[str]) -> None:
     """Start to measure reading duration."""
-    app.env.temp_data['started_at'] = datetime.now()
+    app.env.temp_data['started_at'] = time.monotonic()
 
 
 def on_doctree_read(app: Sphinx, doctree: nodes.document) -> None:
     """Record a reading duration."""
     started_at = app.env.temp_data['started_at']
-    duration = datetime.now() - started_at
+    duration = time.monotonic() - started_at
     domain = cast(DurationDomain, app.env.get_domain('duration'))
     domain.note_reading_duration(duration)
 
 
 def on_build_finished(app: Sphinx, error: Exception) -> None:
-    """Display duration ranking on current build."""
+    """Display duration ranking on the current build."""
     domain = cast(DurationDomain, app.env.get_domain('duration'))
-    durations = sorted(domain.reading_durations.items(), key=itemgetter(1), reverse=True)
-    if not durations:
+    if not domain.reading_durations:
         return
+    durations = sorted(domain.reading_durations.items(), key=itemgetter(1), reverse=True)
 
     logger.info('')
     logger.info(__('====================== slowest reading durations ======================='))
     for docname, d in islice(durations, 5):
-        logger.info('%d.%03d %s', d.seconds, d.microseconds / 1000, docname)
+        logger.info(f'{d:.3f} {docname}')  # NoQA: G004
 
 
-def setup(app: Sphinx) -> dict[str, Any]:
+def setup(app: Sphinx) -> dict[str, bool | str]:
     app.add_domain(DurationDomain)
     app.connect('builder-inited', on_builder_inited)
     app.connect('source-read', on_source_read)

sphinx/ext/extlinks.py

@@ -20,19 +20,24 @@ Both, the url string and the caption string must escape ``%`` as ``%%``.
 from __future__ import annotations
 
 import re
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from docutils import nodes, utils
-from docutils.nodes import Node, system_message
-from docutils.parsers.rst.states import Inliner
 
 import sphinx
-from sphinx.application import Sphinx
 from sphinx.locale import __
 from sphinx.transforms.post_transforms import SphinxPostTransform
 from sphinx.util import logging, rst
 from sphinx.util.nodes import split_explicit_title
-from sphinx.util.typing import RoleFunction
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from docutils.nodes import Node, system_message
+    from docutils.parsers.rst.states import Inliner
+
+    from sphinx.application import Sphinx
+    from sphinx.util.typing import RoleFunction
 
 logger = logging.getLogger(__name__)
 
@@ -91,7 +96,7 @@ def make_link_role(name: str, base_url: str, caption: str) -> RoleFunction:
     # Remark: It is an implementation detail that we use Pythons %-formatting.
     # So far we only expose ``%s`` and require quoting of ``%`` using ``%%``.
     def role(typ: str, rawtext: str, text: str, lineno: int,
-             inliner: Inliner, options: dict = {}, content: list[str] = [],
+             inliner: Inliner, options: dict | None = None, content: Sequence[str] = (),
              ) -> tuple[list[Node], list[system_message]]:
         text = utils.unescape(text)
         has_explicit_title, title, part = split_explicit_title(text)

sphinx/ext/githubpages.py

@@ -2,13 +2,16 @@
 
 from __future__ import annotations
 
+import contextlib
 import os
 import urllib.parse
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import sphinx
-from sphinx.application import Sphinx
-from sphinx.environment import BuildEnvironment
+
+if TYPE_CHECKING:
+    from sphinx.application import Sphinx
+    from sphinx.environment import BuildEnvironment
 
 
 def _get_domain_from_url(url: str) -> str:
@@ -34,7 +37,7 @@ def create_nojekyll_and_cname(app: Sphinx, env: BuildEnvironment) -> None:
     if app.builder.format != 'html':
         return
 
-    open(os.path.join(app.builder.outdir, '.nojekyll'), 'wb').close()
+    app.builder.outdir.joinpath('.nojekyll').touch()
     cname_path = os.path.join(app.builder.outdir, 'CNAME')
 
     domain = _get_domain_from_url(app.config.html_baseurl)
@@ -45,10 +48,8 @@ def create_nojekyll_and_cname(app: Sphinx, env: BuildEnvironment) -> None:
             # auto-generated by the GitHub UI doesn't have one.
             f.write(domain)
     else:
-        try:
+        with contextlib.suppress(FileNotFoundError):
             os.unlink(cname_path)
-        except FileNotFoundError:
-            pass
 
 
 def setup(app: Sphinx) -> dict[str, Any]:

sphinx/ext/graphviz.py

@@ -6,32 +6,37 @@ from __future__ import annotations
 import posixpath
 import re
 import subprocess
+import xml.etree.ElementTree as ET
+from hashlib import sha1
+from itertools import chain
 from os import path
 from subprocess import CalledProcessError
 from typing import TYPE_CHECKING, Any
+from urllib.parse import urlsplit, urlunsplit
 
 from docutils import nodes
-from docutils.nodes import Node
 from docutils.parsers.rst import Directive, directives
 
 import sphinx
-from sphinx.application import Sphinx
 from sphinx.errors import SphinxError
 from sphinx.locale import _, __
-from sphinx.util import logging, sha1
+from sphinx.util import logging
 from sphinx.util.docutils import SphinxDirective, SphinxTranslator
 from sphinx.util.i18n import search_image_for_language
 from sphinx.util.nodes import set_source_info
 from sphinx.util.osutil import ensuredir
-from sphinx.util.typing import OptionSpec
-from sphinx.writers.html import HTML5Translator
-from sphinx.writers.latex import LaTeXTranslator
-from sphinx.writers.manpage import ManualPageTranslator
-from sphinx.writers.texinfo import TexinfoTranslator
-from sphinx.writers.text import TextTranslator
 
 if TYPE_CHECKING:
+    from docutils.nodes import Node
+
+    from sphinx.application import Sphinx
     from sphinx.config import Config
+    from sphinx.util.typing import OptionSpec
+    from sphinx.writers.html import HTML5Translator
+    from sphinx.writers.latex import LaTeXTranslator
+    from sphinx.writers.manpage import ManualPageTranslator
+    from sphinx.writers.texinfo import TexinfoTranslator
+    from sphinx.writers.text import TextTranslator
 
 logger = logging.getLogger(__name__)
 
@@ -62,7 +67,7 @@ class ClickableMapDefinition:
         if self.id == '%3':
             # graphviz generates wrong ID if graph name not specified
             # https://gitlab.com/graphviz/graphviz/issues/1327
-            hashed = sha1(dot.encode()).hexdigest()
+            hashed = sha1(dot.encode(), usedforsecurity=False).hexdigest()
             self.id = 'grapviz%s' % hashed[-10:]
             self.content[0] = self.content[0].replace('%3', self.id)
 
@@ -213,15 +218,50 @@ class GraphvizSimple(SphinxDirective):
             return [figure]
 
 
+def fix_svg_relative_paths(self: SphinxTranslator, filepath: str) -> None:
+    """Change relative links in generated svg files to be relative to imgpath."""
+    tree = ET.parse(filepath)  # NoQA: S314
+    root = tree.getroot()
+    ns = {'svg': 'http://www.w3.org/2000/svg', 'xlink': 'http://www.w3.org/1999/xlink'}
+    href_name = '{http://www.w3.org/1999/xlink}href'
+    modified = False
+
+    for element in chain(
+        root.findall('.//svg:image[@xlink:href]', ns),
+        root.findall('.//svg:a[@xlink:href]', ns),
+    ):
+        scheme, hostname, url, query, fragment = urlsplit(element.attrib[href_name])
+        if hostname:
+            # not a relative link
+            continue
+
+        old_path = path.join(self.builder.outdir, url)
+        new_path = path.relpath(
+            old_path,
+            start=path.join(self.builder.outdir, self.builder.imgpath),
+        )
+        modified_url = urlunsplit((scheme, hostname, new_path, query, fragment))
+
+        element.set(href_name, modified_url)
+        modified = True
+
+    if modified:
+        tree.write(filepath)
+
+
 def render_dot(self: SphinxTranslator, code: str, options: dict, format: str,
                prefix: str = 'graphviz', filename: str | None = None,
                ) -> tuple[str | None, str | None]:
     """Render graphviz code into a PNG or PDF output file."""
     graphviz_dot = options.get('graphviz_dot', self.builder.config.graphviz_dot)
+    if not graphviz_dot:
+        raise GraphvizError(
+            __('graphviz_dot executable path must be set! %r') % graphviz_dot,
+        )
     hashkey = (code + str(options) + str(graphviz_dot) +
                str(self.builder.config.graphviz_dot_args)).encode()
 
-    fname = f'{prefix}-{sha1(hashkey).hexdigest()}.{format}'
+    fname = f'{prefix}-{sha1(hashkey, usedforsecurity=False).hexdigest()}.{format}'
     relfn = posixpath.join(self.builder.imgpath, fname)
     outfn = path.join(self.builder.outdir, self.builder.imagedir, fname)
 
@@ -250,20 +290,24 @@ def render_dot(self: SphinxTranslator, code: str, options: dict, format: str,
     try:
         ret = subprocess.run(dot_args, input=code.encode(), capture_output=True,
                              cwd=cwd, check=True)
-        if not path.isfile(outfn):
-            raise GraphvizError(__('dot did not produce an output file:\n[stderr]\n%r\n'
-                                   '[stdout]\n%r') % (ret.stderr, ret.stdout))
-        return relfn, outfn
     except OSError:
         logger.warning(__('dot command %r cannot be run (needed for graphviz '
                           'output), check the graphviz_dot setting'), graphviz_dot)
         if not hasattr(self.builder, '_graphviz_warned_dot'):
-            self.builder._graphviz_warned_dot = {}  # type: ignore
-        self.builder._graphviz_warned_dot[graphviz_dot] = True  # type: ignore
+            self.builder._graphviz_warned_dot = {}  # type: ignore[attr-defined]
+        self.builder._graphviz_warned_dot[graphviz_dot] = True  # type: ignore[attr-defined]
         return None, None
     except CalledProcessError as exc:
         raise GraphvizError(__('dot exited with error:\n[stderr]\n%r\n'
                                '[stdout]\n%r') % (exc.stderr, exc.stdout)) from exc
+    if not path.isfile(outfn):
+        raise GraphvizError(__('dot did not produce an output file:\n[stderr]\n%r\n'
+                               '[stdout]\n%r') % (ret.stderr, ret.stdout))
+
+    if format == 'svg':
+        fix_svg_relative_paths(self, outfn)
+
+    return relfn, outfn
 
 
 def render_dot_html(self: HTML5Translator, node: graphviz, code: str, options: dict,

sphinx/ext/ifconfig.py

@@ -16,16 +16,19 @@ namespace of the project configuration (that is, all variables from
 
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from docutils import nodes
-from docutils.nodes import Node
 
 import sphinx
-from sphinx.application import Sphinx
 from sphinx.util.docutils import SphinxDirective
 from sphinx.util.nodes import nested_parse_with_titles
-from sphinx.util.typing import OptionSpec
+
+if TYPE_CHECKING:
+    from docutils.nodes import Node
+
+    from sphinx.application import Sphinx
+    from sphinx.util.typing import OptionSpec
 
 
 class ifconfig(nodes.Element):

sphinx/ext/imgconverter.py

@@ -5,15 +5,17 @@ from __future__ import annotations
 import subprocess
 import sys
 from subprocess import CalledProcessError
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import sphinx
-from sphinx.application import Sphinx
 from sphinx.errors import ExtensionError
 from sphinx.locale import __
 from sphinx.transforms.post_transforms.images import ImageConverter
 from sphinx.util import logging
 
+if TYPE_CHECKING:
+    from sphinx.application import Sphinx
+
 logger = logging.getLogger(__name__)
 
 

sphinx/ext/imgmath.py

@@ -3,30 +3,37 @@
 from __future__ import annotations
 
 import base64
+import contextlib
 import re
 import shutil
 import subprocess
 import tempfile
+from hashlib import sha1
 from os import path
 from subprocess import CalledProcessError
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from docutils import nodes
-from docutils.nodes import Element
 
 import sphinx
 from sphinx import package_dir
-from sphinx.application import Sphinx
-from sphinx.builders import Builder
-from sphinx.config import Config
 from sphinx.errors import SphinxError
 from sphinx.locale import _, __
-from sphinx.util import logging, sha1
+from sphinx.util import logging
 from sphinx.util.math import get_node_equation_number, wrap_displaymath
 from sphinx.util.osutil import ensuredir
 from sphinx.util.png import read_png_depth, write_png_depth
 from sphinx.util.template import LaTeXRenderer
-from sphinx.writers.html import HTML5Translator
+
+if TYPE_CHECKING:
+    import os
+
+    from docutils.nodes import Element
+
+    from sphinx.application import Sphinx
+    from sphinx.builders import Builder
+    from sphinx.config import Config
+    from sphinx.writers.html import HTML5Translator
 
 logger = logging.getLogger(__name__)
 
@@ -82,7 +89,7 @@ def write_svg_depth(filename: str, depth: int) -> None:
 def generate_latex_macro(image_format: str,
                          math: str,
                          config: Config,
-                         confdir: str = '') -> str:
+                         confdir: str | os.PathLike[str] = '') -> str:
     """Generate LaTeX macro."""
     variables = {
         'fontsize': config.imgmath_font_size,
@@ -115,9 +122,9 @@ def ensure_tempdir(builder: Builder) -> str:
     just removing the whole directory (see cleanup_tempdir)
     """
     if not hasattr(builder, '_imgmath_tempdir'):
-        builder._imgmath_tempdir = tempfile.mkdtemp()  # type: ignore
+        builder._imgmath_tempdir = tempfile.mkdtemp()  # type: ignore[attr-defined]
 
-    return builder._imgmath_tempdir  # type: ignore
+    return builder._imgmath_tempdir  # type: ignore[attr-defined]
 
 
 def compile_math(latex: str, builder: Builder) -> str:
@@ -152,7 +159,8 @@ def compile_math(latex: str, builder: Builder) -> str:
                        builder.config.imgmath_latex)
         raise InvokeError from exc
     except CalledProcessError as exc:
-        raise MathExtError('latex exited with error', exc.stderr, exc.stdout) from exc
+        msg = 'latex exited with error'
+        raise MathExtError(msg, exc.stderr, exc.stdout) from exc
 
 
 def convert_dvi_to_image(command: list[str], name: str) -> tuple[str, str]:
@@ -232,14 +240,15 @@ def render_math(
     """
     image_format = self.builder.config.imgmath_image_format.lower()
     if image_format not in SUPPORT_FORMAT:
-        raise MathExtError('imgmath_image_format must be either "png" or "svg"')
+        unsupported_format_msg = 'imgmath_image_format must be either "png" or "svg"'
+        raise MathExtError(unsupported_format_msg)
 
     latex = generate_latex_macro(image_format,
                                  math,
                                  self.builder.config,
                                  self.builder.confdir)
 
-    filename = f"{sha1(latex.encode()).hexdigest()}.{image_format}"
+    filename = f"{sha1(latex.encode(), usedforsecurity=False).hexdigest()}.{image_format}"
     generated_path = path.join(self.builder.outdir, self.builder.imagedir, 'math', filename)
     ensuredir(path.dirname(generated_path))
     if path.isfile(generated_path):
@@ -258,7 +267,7 @@ def render_math(
     try:
         dvipath = compile_math(latex, self.builder)
     except InvokeError:
-        self.builder._imgmath_warned_latex = True  # type: ignore
+        self.builder._imgmath_warned_latex = True  # type: ignore[attr-defined]
         return None, None
 
     # .dvi -> .png/.svg
@@ -268,7 +277,7 @@ def render_math(
         elif image_format == 'svg':
             depth = convert_dvi_to_svg(dvipath, self.builder, generated_path)
     except InvokeError:
-        self.builder._imgmath_warned_image_translator = True  # type: ignore
+        self.builder._imgmath_warned_image_translator = True  # type: ignore[attr-defined]
         return None, None
 
     return generated_path, depth
@@ -281,7 +290,8 @@ def render_maths_to_base64(image_format: str, generated_path: str) -> str:
         return f'data:image/png;base64,{encoded}'
     if image_format == 'svg':
         return f'data:image/svg+xml;base64,{encoded}'
-    raise MathExtError('imgmath_image_format must be either "png" or "svg"')
+    unsupported_format_msg = 'imgmath_image_format must be either "png" or "svg"'
+    raise MathExtError(unsupported_format_msg)
 
 
 def clean_up_files(app: Sphinx, exc: Exception) -> None:
@@ -289,18 +299,14 @@ def clean_up_files(app: Sphinx, exc: Exception) -> None:
         return
 
     if hasattr(app.builder, '_imgmath_tempdir'):
-        try:
+        with contextlib.suppress(Exception):
             shutil.rmtree(app.builder._imgmath_tempdir)
-        except Exception:
-            pass
 
     if app.builder.config.imgmath_embed:
         # in embed mode, the images are still generated in the math output dir
         # to be shared across workers, but are not useful to the final document
-        try:
+        with contextlib.suppress(Exception):
             shutil.rmtree(path.join(app.builder.outdir, app.builder.imagedir, 'math'))
-        except Exception:
-            pass
 
 
 def get_tooltip(self: HTML5Translator, node: Element) -> str:
@@ -358,7 +364,7 @@ def html_visit_displaymath(self: HTML5Translator, node: nodes.math_block) -> Non
     if node['number']:
         number = get_node_equation_number(self, node)
         self.body.append('<span class="eqno">(%s)' % number)
-        self.add_permalink_ref(node, _('Permalink to this equation'))
+        self.add_permalink_ref(node, _('Link to this equation'))
         self.body.append('</span>')
 
     if rendered_path is None: