py2docfx 0.1.11.dev1830301__py3-none-any.whl → 0.1.11.dev1860114__py3-none-any.whl

py2docfx/venv/template/Lib/site-packages/sphinx/application.py

@@ -1,1344 +0,0 @@
-"""Sphinx application class and extensibility interface.
-
-Gracefully adapted from the TextPress system by Armin.
-"""
-
-from __future__ import annotations
-
-import os
-import pickle
-import sys
-from collections import deque
-from io import StringIO
-from os import path
-from typing import IO, TYPE_CHECKING, Any, Callable
-
-from docutils import nodes
-from docutils.nodes import Element, TextElement
-from docutils.parsers import Parser
-from docutils.parsers.rst import Directive, roles
-from docutils.transforms import Transform
-from pygments.lexer import Lexer
-
-import sphinx
-from sphinx import locale, package_dir
-from sphinx.config import Config
-from sphinx.domains import Domain, Index
-from sphinx.environment import BuildEnvironment
-from sphinx.environment.collectors import EnvironmentCollector
-from sphinx.errors import ApplicationError, ConfigError, VersionRequirementError
-from sphinx.events import EventManager
-from sphinx.extension import Extension
-from sphinx.highlighting import lexer_classes
-from sphinx.locale import __
-from sphinx.project import Project
-from sphinx.registry import SphinxComponentRegistry
-from sphinx.roles import XRefRole
-from sphinx.theming import Theme
-from sphinx.util import docutils, logging
-from sphinx.util.build_phase import BuildPhase
-from sphinx.util.console import bold  # type: ignore
-from sphinx.util.display import progress_message
-from sphinx.util.i18n import CatalogRepository
-from sphinx.util.logging import prefixed_warnings
-from sphinx.util.osutil import abspath, ensuredir, relpath
-from sphinx.util.tags import Tags
-from sphinx.util.typing import RoleFunction, TitleGetter
-
-if TYPE_CHECKING:
-    from docutils.nodes import Node  # noqa: F401
-
-    from sphinx.builders import Builder
-
-
-builtin_extensions = (
-    'sphinx.addnodes',
-    'sphinx.builders.changes',
-    'sphinx.builders.epub3',
-    'sphinx.builders.dirhtml',
-    'sphinx.builders.dummy',
-    'sphinx.builders.gettext',
-    'sphinx.builders.html',
-    'sphinx.builders.latex',
-    'sphinx.builders.linkcheck',
-    'sphinx.builders.manpage',
-    'sphinx.builders.singlehtml',
-    'sphinx.builders.texinfo',
-    'sphinx.builders.text',
-    'sphinx.builders.xml',
-    'sphinx.config',
-    'sphinx.domains.c',
-    'sphinx.domains.changeset',
-    'sphinx.domains.citation',
-    'sphinx.domains.cpp',
-    'sphinx.domains.index',
-    'sphinx.domains.javascript',
-    'sphinx.domains.math',
-    'sphinx.domains.python',
-    'sphinx.domains.rst',
-    'sphinx.domains.std',
-    'sphinx.directives',
-    'sphinx.directives.code',
-    'sphinx.directives.other',
-    'sphinx.directives.patches',
-    'sphinx.extension',
-    'sphinx.parsers',
-    'sphinx.registry',
-    'sphinx.roles',
-    'sphinx.transforms',
-    'sphinx.transforms.compact_bullet_list',
-    'sphinx.transforms.i18n',
-    'sphinx.transforms.references',
-    'sphinx.transforms.post_transforms',
-    'sphinx.transforms.post_transforms.code',
-    'sphinx.transforms.post_transforms.images',
-    'sphinx.versioning',
-    # collectors should be loaded by specific order
-    'sphinx.environment.collectors.dependencies',
-    'sphinx.environment.collectors.asset',
-    'sphinx.environment.collectors.metadata',
-    'sphinx.environment.collectors.title',
-    'sphinx.environment.collectors.toctree',
-    # 1st party extensions
-    'sphinxcontrib.applehelp',
-    'sphinxcontrib.devhelp',
-    'sphinxcontrib.htmlhelp',
-    'sphinxcontrib.serializinghtml',
-    'sphinxcontrib.qthelp',
-    # Strictly, alabaster theme is not a builtin extension,
-    # but it is loaded automatically to use it as default theme.
-    'alabaster',
-)
-
-ENV_PICKLE_FILENAME = 'environment.pickle'
-
-logger = logging.getLogger(__name__)
-
-
-class Sphinx:
-    """The main application class and extensibility interface.
-
-    :ivar srcdir: Directory containing source.
-    :ivar confdir: Directory containing ``conf.py``.
-    :ivar doctreedir: Directory for storing pickled doctrees.
-    :ivar outdir: Directory for storing build documents.
-    """
-
-    warningiserror: bool
-    _warncount: int
-
-    def __init__(self, srcdir: str, confdir: str | None, outdir: str, doctreedir: str,
-                 buildername: str, confoverrides: dict | None = None,
-                 status: IO | None = sys.stdout, warning: IO | None = sys.stderr,
-                 freshenv: bool = False, warningiserror: bool = False,
-                 tags: list[str] | None = None,
-                 verbosity: int = 0, parallel: int = 0, keep_going: bool = False,
-                 pdb: bool = False) -> None:
-        self.phase = BuildPhase.INITIALIZATION
-        self.verbosity = verbosity
-        self.extensions: dict[str, Extension] = {}
-        self.registry = SphinxComponentRegistry()
-
-        # validate provided directories
-        self.srcdir = abspath(srcdir)
-        self.outdir = abspath(outdir)
-        self.doctreedir = abspath(doctreedir)
-
-        if not path.isdir(self.srcdir):
-            raise ApplicationError(__('Cannot find source directory (%s)') %
-                                   self.srcdir)
-
-        if path.exists(self.outdir) and not path.isdir(self.outdir):
-            raise ApplicationError(__('Output directory (%s) is not a directory') %
-                                   self.outdir)
-
-        if self.srcdir == self.outdir:
-            raise ApplicationError(__('Source directory and destination '
-                                      'directory cannot be identical'))
-
-        self.parallel = parallel
-
-        if status is None:
-            self._status: IO = StringIO()
-            self.quiet: bool = True
-        else:
-            self._status = status
-            self.quiet = False
-
-        if warning is None:
-            self._warning: IO = StringIO()
-        else:
-            self._warning = warning
-        self._warncount = 0
-        self.keep_going = warningiserror and keep_going
-        if self.keep_going:
-            self.warningiserror = False
-        else:
-            self.warningiserror = warningiserror
-        self.pdb = pdb
-        logging.setup(self, self._status, self._warning)
-
-        self.events = EventManager(self)
-
-        # keep last few messages for traceback
-        # This will be filled by sphinx.util.logging.LastMessagesWriter
-        self.messagelog: deque = deque(maxlen=10)
-
-        # say hello to the world
-        logger.info(bold(__('Running Sphinx v%s') % sphinx.__display_version__))
-
-        # status code for command-line application
-        self.statuscode = 0
-
-        # read config
-        self.tags = Tags(tags)
-        if confdir is None:
-            # set confdir to srcdir if -C given (!= no confdir); a few pieces
-            # of code expect a confdir to be set
-            self.confdir = self.srcdir
-            self.config = Config({}, confoverrides or {})
-        else:
-            self.confdir = abspath(confdir)
-            self.config = Config.read(self.confdir, confoverrides or {}, self.tags)
-
-        # initialize some limited config variables before initialize i18n and loading
-        # extensions
-        self.config.pre_init_values()
-
-        # set up translation infrastructure
-        self._init_i18n()
-
-        # check the Sphinx version if requested
-        if self.config.needs_sphinx and self.config.needs_sphinx > sphinx.__display_version__:
-            raise VersionRequirementError(
-                __('This project needs at least Sphinx v%s and therefore cannot '
-                   'be built with this version.') % self.config.needs_sphinx)
-
-        # load all built-in extension modules
-        for extension in builtin_extensions:
-            self.setup_extension(extension)
-
-        # load all user-given extension modules
-        for extension in self.config.extensions:
-            self.setup_extension(extension)
-
-        # preload builder module (before init config values)
-        self.preload_builder(buildername)
-
-        if not path.isdir(outdir):
-            with progress_message(__('making output directory')):
-                ensuredir(outdir)
-
-        # the config file itself can be an extension
-        if self.config.setup:
-            prefix = __('while setting up extension %s:') % "conf.py"
-            with prefixed_warnings(prefix):
-                if callable(self.config.setup):
-                    self.config.setup(self)
-                else:
-                    raise ConfigError(
-                        __("'setup' as currently defined in conf.py isn't a Python callable. "
-                           "Please modify its definition to make it a callable function. "
-                           "This is needed for conf.py to behave as a Sphinx extension.")
-                    )
-
-        # now that we know all config values, collect them from conf.py
-        self.config.init_values()
-        self.events.emit('config-inited', self.config)
-
-        # create the project
-        self.project = Project(self.srcdir, self.config.source_suffix)
-
-        # set up the build environment
-        self.env = self._init_env(freshenv)
-
-        # create the builder
-        self.builder = self.create_builder(buildername)
-
-        # build environment post-initialisation, after creating the builder
-        self._post_init_env()
-
-        # set up the builder
-        self._init_builder()
-
-    def _init_i18n(self) -> None:
-        """Load translated strings from the configured localedirs if enabled in
-        the configuration.
-        """
-        if self.config.language == 'en':
-            self.translator, has_translation = locale.init([], None)
-        else:
-            logger.info(bold(__('loading translations [%s]... ') % self.config.language),
-                        nonl=True)
-
-            # compile mo files if sphinx.po file in user locale directories are updated
-            repo = CatalogRepository(self.srcdir, self.config.locale_dirs,
-                                     self.config.language, self.config.source_encoding)
-            for catalog in repo.catalogs:
-                if catalog.domain == 'sphinx' and catalog.is_outdated():
-                    catalog.write_mo(self.config.language,
-                                     self.config.gettext_allow_fuzzy_translations)
-
-            locale_dirs: list[str | None] = list(repo.locale_dirs)
-            locale_dirs += [None]
-            locale_dirs += [path.join(package_dir, 'locale')]
-
-            self.translator, has_translation = locale.init(locale_dirs, self.config.language)
-            if has_translation:
-                logger.info(__('done'))
-            else:
-                logger.info(__('not available for built-in messages'))
-
-    def _init_env(self, freshenv: bool) -> BuildEnvironment:
-        filename = path.join(self.doctreedir, ENV_PICKLE_FILENAME)
-        if freshenv or not os.path.exists(filename):
-            return self._create_fresh_env()
-        else:
-            return self._load_existing_env(filename)
-
-    def _create_fresh_env(self) -> BuildEnvironment:
-        env = BuildEnvironment(self)
-        self._fresh_env_used = True
-        return env
-
-    def _load_existing_env(self, filename: str) -> BuildEnvironment:
-        try:
-            with progress_message(__('loading pickled environment')):
-                with open(filename, 'rb') as f:
-                    env = pickle.load(f)
-                    env.setup(self)
-                    self._fresh_env_used = False
-        except Exception as err:
-            logger.info(__('failed: %s'), err)
-            env = self._create_fresh_env()
-        return env
-
-    def _post_init_env(self) -> None:
-        if self._fresh_env_used:
-            self.env.find_files(self.config, self.builder)
-        del self._fresh_env_used
-
-    def preload_builder(self, name: str) -> None:
-        self.registry.preload_builder(self, name)
-
-    def create_builder(self, name: str) -> Builder:
-        if name is None:
-            logger.info(__('No builder selected, using default: html'))
-            name = 'html'
-
-        return self.registry.create_builder(self, name, self.env)
-
-    def _init_builder(self) -> None:
-        if not hasattr(self.builder, "env"):
-            self.builder.set_environment(self.env)
-        self.builder.init()
-        self.events.emit('builder-inited')
-
-    # ---- main "build" method -------------------------------------------------
-
-    def build(self, force_all: bool = False, filenames: list[str] | None = None) -> None:
-        self.phase = BuildPhase.READING
-        try:
-            if force_all:
-                self.builder.build_all()
-            elif filenames:
-                self.builder.build_specific(filenames)
-            else:
-                self.builder.build_update()
-
-            self.events.emit('build-finished', None)
-        except Exception as err:
-            # delete the saved env to force a fresh build next time
-            envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME)
-            if path.isfile(envfile):
-                os.unlink(envfile)
-            self.events.emit('build-finished', err)
-            raise
-
-        if self._warncount and self.keep_going:
-            self.statuscode = 1
-
-        status = (__('succeeded') if self.statuscode == 0
-                  else __('finished with problems'))
-        if self._warncount:
-            if self.warningiserror:
-                if self._warncount == 1:
-                    msg = __('build %s, %s warning (with warnings treated as errors).')
-                else:
-                    msg = __('build %s, %s warnings (with warnings treated as errors).')
-            else:
-                if self._warncount == 1:
-                    msg = __('build %s, %s warning.')
-                else:
-                    msg = __('build %s, %s warnings.')
-
-            logger.info(bold(msg % (status, self._warncount)))
-        else:
-            logger.info(bold(__('build %s.') % status))
-
-        if self.statuscode == 0 and self.builder.epilog:
-            logger.info('')
-            logger.info(self.builder.epilog % {
-                'outdir': relpath(self.outdir),
-                'project': self.config.project
-            })
-
-        self.builder.cleanup()
-
-    # ---- general extensibility interface -------------------------------------
-
-    def setup_extension(self, extname: str) -> None:
-        """Import and setup a Sphinx extension module.
-
-        Load the extension given by the module *name*.  Use this if your
-        extension needs the features provided by another extension.  No-op if
-        called twice.
-        """
-        logger.debug('[app] setting up extension: %r', extname)
-        self.registry.load_extension(self, extname)
-
-    def require_sphinx(self, version: str) -> None:
-        """Check the Sphinx version if requested.
-
-        Compare *version* with the version of the running Sphinx, and abort the
-        build when it is too old.
-
-        :param version: The required version in the form of ``major.minor``.
-
-        .. versionadded:: 1.0
-        """
-        if version > sphinx.__display_version__[:3]:
-            raise VersionRequirementError(version)
-
-    # event interface
-    def connect(self, event: str, callback: Callable, priority: int = 500) -> int:
-        """Register *callback* to be called when *event* is emitted.
-
-        For details on available core events and the arguments of callback
-        functions, please see :ref:`events`.
-
-        :param event: The name of target event
-        :param callback: Callback function for the event
-        :param priority: The priority of the callback.  The callbacks will be invoked
-                         in order of *priority* (ascending).
-        :return: A listener ID.  It can be used for :meth:`disconnect`.
-
-        .. versionchanged:: 3.0
-
-           Support *priority*
-        """
-        listener_id = self.events.connect(event, callback, priority)
-        logger.debug('[app] connecting event %r (%d): %r [id=%s]',
-                     event, priority, callback, listener_id)
-        return listener_id
-
-    def disconnect(self, listener_id: int) -> None:
-        """Unregister callback by *listener_id*.
-
-        :param listener_id: A listener_id that :meth:`connect` returns
-        """
-        logger.debug('[app] disconnecting event: [id=%s]', listener_id)
-        self.events.disconnect(listener_id)
-
-    def emit(self, event: str, *args: Any,
-             allowed_exceptions: tuple[type[Exception], ...] = ()) -> list:
-        """Emit *event* and pass *arguments* to the callback functions.
-
-        Return the return values of all callbacks as a list.  Do not emit core
-        Sphinx events in extensions!
-
-        :param event: The name of event that will be emitted
-        :param args: The arguments for the event
-        :param allowed_exceptions: The list of exceptions that are allowed in the callbacks
-
-        .. versionchanged:: 3.1
-
-           Added *allowed_exceptions* to specify path-through exceptions
-        """
-        return self.events.emit(event, *args, allowed_exceptions=allowed_exceptions)
-
-    def emit_firstresult(self, event: str, *args: Any,
-                         allowed_exceptions: tuple[type[Exception], ...] = ()) -> Any:
-        """Emit *event* and pass *arguments* to the callback functions.
-
-        Return the result of the first callback that doesn't return ``None``.
-
-        :param event: The name of event that will be emitted
-        :param args: The arguments for the event
-        :param allowed_exceptions: The list of exceptions that are allowed in the callbacks
-
-        .. versionadded:: 0.5
-        .. versionchanged:: 3.1
-
-           Added *allowed_exceptions* to specify path-through exceptions
-        """
-        return self.events.emit_firstresult(event, *args,
-                                            allowed_exceptions=allowed_exceptions)
-
-    # registering addon parts
-
-    def add_builder(self, builder: type[Builder], override: bool = False) -> None:
-        """Register a new builder.
-
-        :param builder: A builder class
-        :param override: If true, install the builder forcedly even if another builder
-                         is already installed as the same name
-
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        self.registry.add_builder(builder, override=override)
-
-    # TODO(stephenfin): Describe 'types' parameter
-    def add_config_value(self, name: str, default: Any, rebuild: bool | str,
-                         types: Any = ()) -> None:
-        """Register a configuration value.
-
-        This is necessary for Sphinx to recognize new values and set default
-        values accordingly.
-
-
-        :param name: The name of the configuration value.  It is recommended to be prefixed
-                     with the extension name (ex. ``html_logo``, ``epub_title``)
-        :param default: The default value of the configuration.
-        :param rebuild: The condition of rebuild.  It must be one of those values:
-
-                        * ``'env'`` if a change in the setting only takes effect when a
-                          document is parsed -- this means that the whole environment must be
-                          rebuilt.
-                        * ``'html'`` if a change in the setting needs a full rebuild of HTML
-                          documents.
-                        * ``''`` if a change in the setting will not need any special rebuild.
-        :param types: The type of configuration value.  A list of types can be specified.  For
-                      example, ``[str]`` is used to describe a configuration that takes string
-                      value.
-
-        .. versionchanged:: 0.4
-           If the *default* value is a callable, it will be called with the
-           config object as its argument in order to get the default value.
-           This can be used to implement config values whose default depends on
-           other values.
-
-        .. versionchanged:: 0.6
-           Changed *rebuild* from a simple boolean (equivalent to ``''`` or
-           ``'env'``) to a string.  However, booleans are still accepted and
-           converted internally.
-        """
-        logger.debug('[app] adding config value: %r', (name, default, rebuild, types))
-        if rebuild in (False, True):
-            rebuild = 'env' if rebuild else ''
-        self.config.add(name, default, rebuild, types)
-
-    def add_event(self, name: str) -> None:
-        """Register an event called *name*.
-
-        This is needed to be able to emit it.
-
-        :param name: The name of the event
-        """
-        logger.debug('[app] adding event: %r', name)
-        self.events.add(name)
-
-    def set_translator(self, name: str, translator_class: type[nodes.NodeVisitor],
-                       override: bool = False) -> None:
-        """Register or override a Docutils translator class.
-
-        This is used to register a custom output translator or to replace a
-        builtin translator.  This allows extensions to use a custom translator
-        and define custom nodes for the translator (see :meth:`add_node`).
-
-        :param name: The name of the builder for the translator
-        :param translator_class: A translator class
-        :param override: If true, install the translator forcedly even if another translator
-                         is already installed as the same name
-
-        .. versionadded:: 1.3
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        self.registry.add_translator(name, translator_class, override=override)
-
-    def add_node(self, node: type[Element], override: bool = False,
-                 **kwargs: tuple[Callable, Callable | None]) -> None:
-        """Register a Docutils node class.
-
-        This is necessary for Docutils internals.  It may also be used in the
-        future to validate nodes in the parsed documents.
-
-        :param node: A node class
-        :param kwargs: Visitor functions for each builder (see below)
-        :param override: If true, install the node forcedly even if another node is already
-                         installed as the same name
-
-        Node visitor functions for the Sphinx HTML, LaTeX, text and manpage
-        writers can be given as keyword arguments: the keyword should be one or
-        more of ``'html'``, ``'latex'``, ``'text'``, ``'man'``, ``'texinfo'``
-        or any other supported translators, the value a 2-tuple of ``(visit,
-        depart)`` methods.  ``depart`` can be ``None`` if the ``visit``
-        function raises :exc:`docutils.nodes.SkipNode`.  Example:
-
-        .. code-block:: python
-
-           class math(docutils.nodes.Element): pass
-
-           def visit_math_html(self, node):
-               self.body.append(self.starttag(node, 'math'))
-           def depart_math_html(self, node):
-               self.body.append('</math>')
-
-           app.add_node(math, html=(visit_math_html, depart_math_html))
-
-        Obviously, translators for which you don't specify visitor methods will
-        choke on the node when encountered in a document to translate.
-
-        .. versionchanged:: 0.5
-           Added the support for keyword arguments giving visit functions.
-        """
-        logger.debug('[app] adding node: %r', (node, kwargs))
-        if not override and docutils.is_node_registered(node):
-            logger.warning(__('node class %r is already registered, '
-                              'its visitors will be overridden'),
-                           node.__name__, type='app', subtype='add_node')
-        docutils.register_node(node)
-        self.registry.add_translation_handlers(node, **kwargs)
-
-    def add_enumerable_node(self, node: type[Element], figtype: str,
-                            title_getter: TitleGetter | None = None, override: bool = False,
-                            **kwargs: tuple[Callable, Callable]) -> None:
-        """Register a Docutils node class as a numfig target.
-
-        Sphinx numbers the node automatically. And then the users can refer it
-        using :rst:role:`numref`.
-
-        :param node: A node class
-        :param figtype: The type of enumerable nodes.  Each figtype has individual numbering
-                        sequences.  As system figtypes, ``figure``, ``table`` and
-                        ``code-block`` are defined.  It is possible to add custom nodes to
-                        these default figtypes.  It is also possible to define new custom
-                        figtype if a new figtype is given.
-        :param title_getter: A getter function to obtain the title of node.  It takes an
-                             instance of the enumerable node, and it must return its title as
-                             string.  The title is used to the default title of references for
-                             :rst:role:`ref`.  By default, Sphinx searches
-                             ``docutils.nodes.caption`` or ``docutils.nodes.title`` from the
-                             node as a title.
-        :param kwargs: Visitor functions for each builder (same as :meth:`add_node`)
-        :param override: If true, install the node forcedly even if another node is already
-                         installed as the same name
-
-        .. versionadded:: 1.4
-        """
-        self.registry.add_enumerable_node(node, figtype, title_getter, override=override)
-        self.add_node(node, override=override, **kwargs)
-
-    def add_directive(self, name: str, cls: type[Directive], override: bool = False) -> None:
-        """Register a Docutils directive.
-
-        :param name: The name of the directive
-        :param cls: A directive class
-        :param override: If false, do not install it if another directive
-                         is already installed as the same name
-                         If true, unconditionally install the directive.
-
-        For example, a custom directive named ``my-directive`` would be added
-        like this:
-
-        .. code-block:: python
-
-           from docutils.parsers.rst import Directive, directives
-
-           class MyDirective(Directive):
-               has_content = True
-               required_arguments = 1
-               optional_arguments = 0
-               final_argument_whitespace = True
-               option_spec = {
-                   'class': directives.class_option,
-                   'name': directives.unchanged,
-               }
-
-               def run(self):
-                   ...
-
-           def setup(app):
-               app.add_directive('my-directive', MyDirective)
-
-        For more details, see `the Docutils docs
-        <https://docutils.sourceforge.io/docs/howto/rst-directives.html>`__ .
-
-        .. versionchanged:: 0.6
-           Docutils 0.5-style directive classes are now supported.
-        .. deprecated:: 1.8
-           Docutils 0.4-style (function based) directives support is deprecated.
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        logger.debug('[app] adding directive: %r', (name, cls))
-        if not override and docutils.is_directive_registered(name):
-            logger.warning(__('directive %r is already registered, it will be overridden'),
-                           name, type='app', subtype='add_directive')
-
-        docutils.register_directive(name, cls)
-
-    def add_role(self, name: str, role: Any, override: bool = False) -> None:
-        """Register a Docutils role.
-
-        :param name: The name of role
-        :param role: A role function
-        :param override: If false, do not install it if another role
-                         is already installed as the same name
-                         If true, unconditionally install the role.
-
-        For more details about role functions, see `the Docutils docs
-        <https://docutils.sourceforge.io/docs/howto/rst-roles.html>`__ .
-
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        logger.debug('[app] adding role: %r', (name, role))
-        if not override and docutils.is_role_registered(name):
-            logger.warning(__('role %r is already registered, it will be overridden'),
-                           name, type='app', subtype='add_role')
-        docutils.register_role(name, role)
-
-    def add_generic_role(self, name: str, nodeclass: Any, override: bool = False) -> None:
-        """Register a generic Docutils role.
-
-        Register a Docutils role that does nothing but wrap its contents in the
-        node given by *nodeclass*.
-
-        :param override: If false, do not install it if another role
-                         is already installed as the same name
-                         If true, unconditionally install the role.
-
-        .. versionadded:: 0.6
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        # Don't use ``roles.register_generic_role`` because it uses
-        # ``register_canonical_role``.
-        logger.debug('[app] adding generic role: %r', (name, nodeclass))
-        if not override and docutils.is_role_registered(name):
-            logger.warning(__('role %r is already registered, it will be overridden'),
-                           name, type='app', subtype='add_generic_role')
-        role = roles.GenericRole(name, nodeclass)
-        docutils.register_role(name, role)
-
-    def add_domain(self, domain: type[Domain], override: bool = False) -> None:
-        """Register a domain.
-
-        :param domain: A domain class
-        :param override: If false, do not install it if another domain
-                         is already installed as the same name
-                         If true, unconditionally install the domain.
-
-        .. versionadded:: 1.0
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        self.registry.add_domain(domain, override=override)
-
-    def add_directive_to_domain(self, domain: str, name: str,
-                                cls: type[Directive], override: bool = False) -> None:
-        """Register a Docutils directive in a domain.
-
-        Like :meth:`add_directive`, but the directive is added to the domain
-        named *domain*.
-
-        :param domain: The name of target domain
-        :param name: A name of directive
-        :param cls: A directive class
-        :param override: If false, do not install it if another directive
-                         is already installed as the same name
-                         If true, unconditionally install the directive.
-
-        .. versionadded:: 1.0
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        self.registry.add_directive_to_domain(domain, name, cls, override=override)
-
-    def add_role_to_domain(self, domain: str, name: str, role: RoleFunction | XRefRole,
-                           override: bool = False) -> None:
-        """Register a Docutils role in a domain.
-
-        Like :meth:`add_role`, but the role is added to the domain named
-        *domain*.
-
-        :param domain: The name of the target domain
-        :param name: The name of the role
-        :param role: The role function
-        :param override: If false, do not install it if another role
-                         is already installed as the same name
-                         If true, unconditionally install the role.
-
-        .. versionadded:: 1.0
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        self.registry.add_role_to_domain(domain, name, role, override=override)
-
-    def add_index_to_domain(self, domain: str, index: type[Index], override: bool = False
-                            ) -> None:
-        """Register a custom index for a domain.
-
-        Add a custom *index* class to the domain named *domain*.
-
-        :param domain: The name of the target domain
-        :param index: The index class
-        :param override: If false, do not install it if another index
-                         is already installed as the same name
-                         If true, unconditionally install the index.
-
-        .. versionadded:: 1.0
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        self.registry.add_index_to_domain(domain, index)
-
-    def add_object_type(self, directivename: str, rolename: str, indextemplate: str = '',
-                        parse_node: Callable | None = None,
-                        ref_nodeclass: type[TextElement] | None = None,
-                        objname: str = '', doc_field_types: list = [], override: bool = False
-                        ) -> None:
-        """Register a new object type.
-
-        This method is a very convenient way to add a new :term:`object` type
-        that can be cross-referenced.  It will do this:
-
-        - Create a new directive (called *directivename*) for documenting an
-          object.  It will automatically add index entries if *indextemplate*
-          is nonempty; if given, it must contain exactly one instance of
-          ``%s``.  See the example below for how the template will be
-          interpreted.
-        - Create a new role (called *rolename*) to cross-reference to these
-          object descriptions.
-        - If you provide *parse_node*, it must be a function that takes a
-          string and a docutils node, and it must populate the node with
-          children parsed from the string.  It must then return the name of the
-          item to be used in cross-referencing and index entries.  See the
-          :file:`conf.py` file in the source for this documentation for an
-          example.
-        - The *objname* (if not given, will default to *directivename*) names
-          the type of object.  It is used when listing objects, e.g. in search
-          results.
-
-        For example, if you have this call in a custom Sphinx extension::
-
-           app.add_object_type('directive', 'dir', 'pair: %s; directive')
-
-        you can use this markup in your documents::
-
-           .. rst:directive:: function
-
-              Document a function.
-
-           <...>
-
-           See also the :rst:dir:`function` directive.
-
-        For the directive, an index entry will be generated as if you had prepended ::
-
-           .. index:: pair: function; directive
-
-        The reference node will be of class ``literal`` (so it will be rendered
-        in a proportional font, as appropriate for code) unless you give the
-        *ref_nodeclass* argument, which must be a docutils node class.  Most
-        useful are ``docutils.nodes.emphasis`` or ``docutils.nodes.strong`` --
-        you can also use ``docutils.nodes.generated`` if you want no further
-        text decoration.  If the text should be treated as literal (e.g. no
-        smart quote replacement), but not have typewriter styling, use
-        ``sphinx.addnodes.literal_emphasis`` or
-        ``sphinx.addnodes.literal_strong``.
-
-        For the role content, you have the same syntactical possibilities as
-        for standard Sphinx roles (see :ref:`xref-syntax`).
-
-        If *override* is True, the given object_type is forcedly installed even if
-        an object_type having the same name is already installed.
-
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        self.registry.add_object_type(directivename, rolename, indextemplate, parse_node,
-                                      ref_nodeclass, objname, doc_field_types,
-                                      override=override)
-
-    def add_crossref_type(self, directivename: str, rolename: str, indextemplate: str = '',
-                          ref_nodeclass: type[TextElement] | None = None, objname: str = '',
-                          override: bool = False) -> None:
-        """Register a new crossref object type.
-
-        This method is very similar to :meth:`add_object_type` except that the
-        directive it generates must be empty, and will produce no output.
-
-        That means that you can add semantic targets to your sources, and refer
-        to them using custom roles instead of generic ones (like
-        :rst:role:`ref`).  Example call::
-
-           app.add_crossref_type('topic', 'topic', 'single: %s',
-                                 docutils.nodes.emphasis)
-
-        Example usage::
-
-           .. topic:: application API
-
-           The application API
-           -------------------
-
-           Some random text here.
-
-           See also :topic:`this section <application API>`.
-
-        (Of course, the element following the ``topic`` directive needn't be a
-        section.)
-
-
-        :param override: If false, do not install it if another cross-reference type
-                         is already installed as the same name
-                         If true, unconditionally install the cross-reference type.
-
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        self.registry.add_crossref_type(directivename, rolename,
-                                        indextemplate, ref_nodeclass, objname,
-                                        override=override)
-
-    def add_transform(self, transform: type[Transform]) -> None:
-        """Register a Docutils transform to be applied after parsing.
-
-        Add the standard docutils :class:`Transform` subclass *transform* to
-        the list of transforms that are applied after Sphinx parses a reST
-        document.
-
-        :param transform: A transform class
-
-        .. list-table:: priority range categories for Sphinx transforms
-           :widths: 20,80
-
-           * - Priority
-             - Main purpose in Sphinx
-           * - 0-99
-             - Fix invalid nodes by docutils. Translate a doctree.
-           * - 100-299
-             - Preparation
-           * - 300-399
-             - early
-           * - 400-699
-             - main
-           * - 700-799
-             - Post processing. Deadline to modify text and referencing.
-           * - 800-899
-             - Collect referencing and referenced nodes. Domain processing.
-           * - 900-999
-             - Finalize and clean up.
-
-        refs: `Transform Priority Range Categories`__
-
-        __ https://docutils.sourceforge.io/docs/ref/transforms.html#transform-priority-range-categories
-        """  # noqa: E501
-        self.registry.add_transform(transform)
-
-    def add_post_transform(self, transform: type[Transform]) -> None:
-        """Register a Docutils transform to be applied before writing.
-
-        Add the standard docutils :class:`Transform` subclass *transform* to
-        the list of transforms that are applied before Sphinx writes a
-        document.
-
-        :param transform: A transform class
-        """
-        self.registry.add_post_transform(transform)
-
-    def add_js_file(self, filename: str | None, priority: int = 500,
-                    loading_method: str | None = None, **kwargs: Any) -> None:
-        """Register a JavaScript file to include in the HTML output.
-
-        :param filename: The name of a JavaScript file that the default HTML
-                         template will include. It must be relative to the HTML
-                         static path, or a full URI with scheme, or ``None`` .
-                         The ``None`` value is used to create an inline
-                         ``<script>`` tag.  See the description of *kwargs*
-                         below.
-        :param priority: Files are included in ascending order of priority. If
-                         multiple JavaScript files have the same priority,
-                         those files will be included in order of registration.
-                         See list of "prority range for JavaScript files" below.
-        :param loading_method: The loading method for the JavaScript file.
-                               Either ``'async'`` or ``'defer'`` are allowed.
-        :param kwargs: Extra keyword arguments are included as attributes of the
-                       ``<script>`` tag.  If the special keyword argument
-                       ``body`` is given, its value will be added as the content
-                       of the  ``<script>`` tag.
-
-        Example::
-
-            app.add_js_file('example.js')
-            # => <script src="_static/example.js"></script>
-
-            app.add_js_file('example.js', loading_method="async")
-            # => <script src="_static/example.js" async="async"></script>
-
-            app.add_js_file(None, body="var myVariable = 'foo';")
-            # => <script>var myVariable = 'foo';</script>
-
-        .. list-table:: priority range for JavaScript files
-           :widths: 20,80
-
-           * - Priority
-             - Main purpose in Sphinx
-           * - 200
-             - default priority for built-in JavaScript files
-           * - 500
-             - default priority for extensions
-           * - 800
-             - default priority for :confval:`html_js_files`
-
-        A JavaScript file can be added to the specific HTML page when an extension
-        calls this method on :event:`html-page-context` event.
-
-        .. versionadded:: 0.5
-
-        .. versionchanged:: 1.8
-           Renamed from ``app.add_javascript()``.
-           And it allows keyword arguments as attributes of script tag.
-
-        .. versionchanged:: 3.5
-           Take priority argument.  Allow to add a JavaScript file to the specific page.
-        .. versionchanged:: 4.4
-           Take loading_method argument.  Allow to change the loading method of the
-           JavaScript file.
-        """
-        if loading_method == 'async':
-            kwargs['async'] = 'async'
-        elif loading_method == 'defer':
-            kwargs['defer'] = 'defer'
-
-        self.registry.add_js_file(filename, priority=priority, **kwargs)
-        if hasattr(self, 'builder') and hasattr(self.builder, 'add_js_file'):
-            self.builder.add_js_file(filename,
-                                     priority=priority, **kwargs)
-
-    def add_css_file(self, filename: str, priority: int = 500, **kwargs: Any) -> None:
-        """Register a stylesheet to include in the HTML output.
-
-        :param filename: The name of a CSS file that the default HTML
-                         template will include. It must be relative to the HTML
-                         static path, or a full URI with scheme.
-        :param priority: Files are included in ascending order of priority. If
-                         multiple CSS files have the same priority,
-                         those files will be included in order of registration.
-                         See list of "prority range for CSS files" below.
-        :param kwargs: Extra keyword arguments are included as attributes of the
-                       ``<link>`` tag.
-
-        Example::
-
-            app.add_css_file('custom.css')
-            # => <link rel="stylesheet" href="_static/custom.css" type="text/css" />
-
-            app.add_css_file('print.css', media='print')
-            # => <link rel="stylesheet" href="_static/print.css"
-            #          type="text/css" media="print" />
-
-            app.add_css_file('fancy.css', rel='alternate stylesheet', title='fancy')
-            # => <link rel="alternate stylesheet" href="_static/fancy.css"
-            #          type="text/css" title="fancy" />
-
-        .. list-table:: priority range for CSS files
-           :widths: 20,80
-
-           * - Priority
-             - Main purpose in Sphinx
-           * - 200
-             - default priority for built-in CSS files
-           * - 500
-             - default priority for extensions
-           * - 800
-             - default priority for :confval:`html_css_files`
-
-        A CSS file can be added to the specific HTML page when an extension calls
-        this method on :event:`html-page-context` event.
-
-        .. versionadded:: 1.0
-
-        .. versionchanged:: 1.6
-           Optional ``alternate`` and/or ``title`` attributes can be supplied
-           with the arguments *alternate* (a Boolean) and *title* (a string).
-           The default is no title and *alternate* = ``False``. For
-           more information, refer to the `documentation
-           <https://mdn.io/Web/CSS/Alternative_style_sheets>`__.
-
-        .. versionchanged:: 1.8
-           Renamed from ``app.add_stylesheet()``.
-           And it allows keyword arguments as attributes of link tag.
-
-        .. versionchanged:: 3.5
-           Take priority argument.  Allow to add a CSS file to the specific page.
-        """
-        logger.debug('[app] adding stylesheet: %r', filename)
-        self.registry.add_css_files(filename, priority=priority, **kwargs)
-        if hasattr(self, 'builder') and hasattr(self.builder, 'add_css_file'):
-            self.builder.add_css_file(filename,
-                                      priority=priority, **kwargs)
-
-    def add_latex_package(self, packagename: str, options: str | None = None,
-                          after_hyperref: bool = False) -> None:
-        r"""Register a package to include in the LaTeX source code.
-
-        Add *packagename* to the list of packages that LaTeX source code will
-        include.  If you provide *options*, it will be taken to the `\usepackage`
-        declaration.  If you set *after_hyperref* truthy, the package will be
-        loaded after ``hyperref`` package.
-
-        .. code-block:: python
-
-           app.add_latex_package('mypackage')
-           # => \usepackage{mypackage}
-           app.add_latex_package('mypackage', 'foo,bar')
-           # => \usepackage[foo,bar]{mypackage}
-
-        .. versionadded:: 1.3
-        .. versionadded:: 3.1
-
-           *after_hyperref* option.
-        """
-        self.registry.add_latex_package(packagename, options, after_hyperref)
-
-    def add_lexer(self, alias: str, lexer: type[Lexer]) -> None:
-        """Register a new lexer for source code.
-
-        Use *lexer* to highlight code blocks with the given language *alias*.
-
-        .. versionadded:: 0.6
-        .. versionchanged:: 2.1
-           Take a lexer class as an argument.  An instance of lexers are
-           still supported until Sphinx-3.x.
-        """
-        logger.debug('[app] adding lexer: %r', (alias, lexer))
-        lexer_classes[alias] = lexer
-
-    def add_autodocumenter(self, cls: Any, override: bool = False) -> None:
-        """Register a new documenter class for the autodoc extension.
-
-        Add *cls* as a new documenter class for the :mod:`sphinx.ext.autodoc`
-        extension.  It must be a subclass of
-        :class:`sphinx.ext.autodoc.Documenter`.  This allows auto-documenting
-        new types of objects.  See the source of the autodoc module for
-        examples on how to subclass :class:`Documenter`.
-
-        If *override* is True, the given *cls* is forcedly installed even if
-        a documenter having the same name is already installed.
-
-        See :ref:`autodoc_ext_tutorial`.
-
-        .. versionadded:: 0.6
-        .. versionchanged:: 2.2
-           Add *override* keyword.
-        """
-        logger.debug('[app] adding autodocumenter: %r', cls)
-        from sphinx.ext.autodoc.directive import AutodocDirective
-        self.registry.add_documenter(cls.objtype, cls)
-        self.add_directive('auto' + cls.objtype, AutodocDirective, override=override)
-
-    def add_autodoc_attrgetter(self, typ: type, getter: Callable[[Any, str, Any], Any]
-                               ) -> None:
-        """Register a new ``getattr``-like function for the autodoc extension.
-
-        Add *getter*, which must be a function with an interface compatible to
-        the :func:`getattr` builtin, as the autodoc attribute getter for
-        objects that are instances of *typ*.  All cases where autodoc needs to
-        get an attribute of a type are then handled by this function instead of
-        :func:`getattr`.
-
-        .. versionadded:: 0.6
-        """
-        logger.debug('[app] adding autodoc attrgetter: %r', (typ, getter))
-        self.registry.add_autodoc_attrgetter(typ, getter)
-
-    def add_search_language(self, cls: Any) -> None:
-        """Register a new language for the HTML search index.
-
-        Add *cls*, which must be a subclass of
-        :class:`sphinx.search.SearchLanguage`, as a support language for
-        building the HTML full-text search index.  The class must have a *lang*
-        attribute that indicates the language it should be used for.  See
-        :confval:`html_search_language`.
-
-        .. versionadded:: 1.1
-        """
-        logger.debug('[app] adding search language: %r', cls)
-        from sphinx.search import SearchLanguage, languages
-        assert issubclass(cls, SearchLanguage)
-        languages[cls.lang] = cls
-
-    def add_source_suffix(self, suffix: str, filetype: str, override: bool = False) -> None:
-        """Register a suffix of source files.
-
-        Same as :confval:`source_suffix`.  The users can override this
-        using the config setting.
-
-        :param override: If false, do not install it the same suffix
-                         is already installed.
-                         If true, unconditionally install the suffix.
-
-        .. versionadded:: 1.8
-        """
-        self.registry.add_source_suffix(suffix, filetype, override=override)
-
-    def add_source_parser(self, parser: type[Parser], override: bool = False) -> None:
-        """Register a parser class.
-
-        :param override: If false, do not install it if another parser
-                         is already installed for the same suffix.
-                         If true, unconditionally install the parser.
-
-        .. versionadded:: 1.4
-        .. versionchanged:: 1.8
-           *suffix* argument is deprecated.  It only accepts *parser* argument.
-           Use :meth:`add_source_suffix` API to register suffix instead.
-        .. versionchanged:: 1.8
-           Add *override* keyword.
-        """
-        self.registry.add_source_parser(parser, override=override)
-
-    def add_env_collector(self, collector: type[EnvironmentCollector]) -> None:
-        """Register an environment collector class.
-
-        Refer to :ref:`collector-api`.
-
-        .. versionadded:: 1.6
-        """
-        logger.debug('[app] adding environment collector: %r', collector)
-        collector().enable(self)
-
-    def add_html_theme(self, name: str, theme_path: str) -> None:
-        """Register a HTML Theme.
-
-        The *name* is a name of theme, and *theme_path* is a full path to the
-        theme (refs: :ref:`distribute-your-theme`).
-
-        .. versionadded:: 1.6
-        """
-        logger.debug('[app] adding HTML theme: %r, %r', name, theme_path)
-        self.registry.add_html_theme(name, theme_path)
-
-    def add_html_math_renderer(self, name: str,
-                               inline_renderers: tuple[Callable, Callable] = None,
-                               block_renderers: tuple[Callable, Callable] = None) -> None:
-        """Register a math renderer for HTML.
-
-        The *name* is a name of math renderer.  Both *inline_renderers* and
-        *block_renderers* are used as visitor functions for the HTML writer:
-        the former for inline math node (``nodes.math``), the latter for
-        block math node (``nodes.math_block``).  Regarding visitor functions,
-        see :meth:`add_node` for details.
-
-        .. versionadded:: 1.8
-
-        """
-        self.registry.add_html_math_renderer(name, inline_renderers, block_renderers)
-
-    def add_message_catalog(self, catalog: str, locale_dir: str) -> None:
-        """Register a message catalog.
-
-        :param catalog: The name of the catalog
-        :param locale_dir: The base path of the message catalog
-
-        For more details, see :func:`sphinx.locale.get_translation()`.
-
-        .. versionadded:: 1.8
-        """
-        locale.init([locale_dir], self.config.language, catalog)
-        locale.init_console(locale_dir, catalog)
-
-    # ---- other methods -------------------------------------------------
-    def is_parallel_allowed(self, typ: str) -> bool:
-        """Check whether parallel processing is allowed or not.
-
-        :param typ: A type of processing; ``'read'`` or ``'write'``.
-        """
-        if typ == 'read':
-            attrname = 'parallel_read_safe'
-            message_not_declared = __("the %s extension does not declare if it "
-                                      "is safe for parallel reading, assuming "
-                                      "it isn't - please ask the extension author "
-                                      "to check and make it explicit")
-            message_not_safe = __("the %s extension is not safe for parallel reading")
-        elif typ == 'write':
-            attrname = 'parallel_write_safe'
-            message_not_declared = __("the %s extension does not declare if it "
-                                      "is safe for parallel writing, assuming "
-                                      "it isn't - please ask the extension author "
-                                      "to check and make it explicit")
-            message_not_safe = __("the %s extension is not safe for parallel writing")
-        else:
-            raise ValueError('parallel type %s is not supported' % typ)
-
-        for ext in self.extensions.values():
-            allowed = getattr(ext, attrname, None)
-            if allowed is None:
-                logger.warning(message_not_declared, ext.name)
-                logger.warning(__('doing serial %s'), typ)
-                return False
-            elif not allowed:
-                logger.warning(message_not_safe, ext.name)
-                logger.warning(__('doing serial %s'), typ)
-                return False
-
-        return True
-
-    def set_html_assets_policy(self, policy):
-        """Set the policy to include assets in HTML pages.
-
-        - always: include the assets in all the pages
-        - per_page: include the assets only in pages where they are used
-
-        .. versionadded: 4.1
-        """
-        if policy not in ('always', 'per_page'):
-            raise ValueError('policy %s is not supported' % policy)
-        self.registry.html_assets_policy = policy
-
-
-class TemplateBridge:
-    """
-    This class defines the interface for a "template bridge", that is, a class
-    that renders templates given a template name and a context.
-    """
-
-    def init(
-        self,
-        builder: Builder,
-        theme: Theme | None = None,
-        dirs: list[str] | None = None
-    ) -> None:
-        """Called by the builder to initialize the template system.
-
-        *builder* is the builder object; you'll probably want to look at the
-        value of ``builder.config.templates_path``.
-
-        *theme* is a :class:`sphinx.theming.Theme` object or None; in the latter
-        case, *dirs* can be list of fixed directories to look for templates.
-        """
-        raise NotImplementedError('must be implemented in subclasses')
-
-    def newest_template_mtime(self) -> float:
-        """Called by the builder to determine if output files are outdated
-        because of template changes.  Return the mtime of the newest template
-        file that was changed.  The default implementation returns ``0``.
-        """
-        return 0
-
-    def render(self, template: str, context: dict) -> None:
-        """Called by the builder to render a template given as a filename with
-        a specified context (a Python dictionary).
-        """
-        raise NotImplementedError('must be implemented in subclasses')
-
-    def render_string(self, template: str, context: dict) -> str:
-        """Called by the builder to render a template given as a string with a
-        specified context (a Python dictionary).
-        """
-        raise NotImplementedError('must be implemented in subclasses')