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

sphinx/parsers.py

@@ -9,15 +9,16 @@ import docutils.parsers.rst
 from docutils import nodes
 from docutils.parsers.rst import states
 from docutils.statemachine import StringList
-from docutils.transforms import Transform
 from docutils.transforms.universal import SmartQuotes
 
-from sphinx.config import Config
-from sphinx.environment import BuildEnvironment
 from sphinx.util.rst import append_epilog, prepend_prolog
 
 if TYPE_CHECKING:
+    from docutils.transforms import Transform
+
     from sphinx.application import Sphinx
+    from sphinx.config import Config
+    from sphinx.environment import BuildEnvironment
 
 
 class Parser(docutils.parsers.Parser):
@@ -60,7 +61,7 @@ class RSTParser(docutils.parsers.rst.Parser, Parser):
 
     def parse(self, inputstring: str | StringList, document: nodes.document) -> None:
         """Parse text and generate a document tree."""
-        self.setup_parse(inputstring, document)  # type: ignore
+        self.setup_parse(inputstring, document)  # type: ignore[arg-type]
         self.statemachine = states.RSTStateMachine(
             state_classes=self.state_classes,
             initial_state=self.initial_state,

sphinx/project.py

@@ -2,14 +2,18 @@
 
 from __future__ import annotations
 
+import contextlib
 import os
 from glob import glob
-from typing import Iterable
+from typing import TYPE_CHECKING
 
 from sphinx.locale import __
 from sphinx.util import logging
 from sphinx.util.matching import get_matching_files
-from sphinx.util.osutil import SEP, path_stabilize, relpath
+from sphinx.util.osutil import path_stabilize, relpath
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 
 logger = logging.getLogger(__name__)
 EXCLUDE_PATHS = ['**/_sources', '.#*', '**/.#*', '*.lproj/**']
@@ -18,77 +22,91 @@ EXCLUDE_PATHS = ['**/_sources', '.#*', '**/.#*', '*.lproj/**']
 class Project:
     """A project is the source code set of the Sphinx document(s)."""
 
-    def __init__(self, srcdir: str, source_suffix: dict[str, str]) -> None:
+    def __init__(self, srcdir: str | os.PathLike[str], source_suffix: Iterable[str]) -> None:
         #: Source directory.
         self.srcdir = srcdir
 
         #: source_suffix. Same as :confval:`source_suffix`.
-        self.source_suffix = source_suffix
+        self.source_suffix = tuple(source_suffix)
+        self._first_source_suffix = next(iter(self.source_suffix), "")
 
-        #: The name of documents belongs to this project.
+        #: The name of documents belonging to this project.
         self.docnames: set[str] = set()
 
+        # Bijective mapping between docnames and (srcdir relative) paths.
+        self._path_to_docname: dict[str, str] = {}
+        self._docname_to_path: dict[str, str] = {}
+
     def restore(self, other: Project) -> None:
         """Take over a result of last build."""
         self.docnames = other.docnames
+        self._path_to_docname = other._path_to_docname
+        self._docname_to_path = other._docname_to_path
 
     def discover(self, exclude_paths: Iterable[str] = (),
                  include_paths: Iterable[str] = ("**",)) -> set[str]:
         """Find all document files in the source directory and put them in
         :attr:`docnames`.
         """
-        self.docnames = set()
+
+        self.docnames.clear()
+        self._path_to_docname.clear()
+        self._docname_to_path.clear()
+
         for filename in get_matching_files(
             self.srcdir,
             include_paths,
             [*exclude_paths] + EXCLUDE_PATHS,
         ):
-            docname = self.path2doc(filename)
-            if docname:
+            if docname := self.path2doc(filename):
                 if docname in self.docnames:
                     pattern = os.path.join(self.srcdir, docname) + '.*'
                     files = [relpath(f, self.srcdir) for f in glob(pattern)]
                     logger.warning(__('multiple files found for the document "%s": %r\n'
                                       'Use %r for the build.'),
-                                   docname, files, self.doc2path(docname), once=True)
+                                   docname, files, self.doc2path(docname, absolute=True),
+                                   once=True)
                 elif os.access(os.path.join(self.srcdir, filename), os.R_OK):
                     self.docnames.add(docname)
+                    self._path_to_docname[filename] = docname
+                    self._docname_to_path[docname] = filename
                 else:
-                    logger.warning(__("document not readable. Ignored."), location=docname)
+                    logger.warning(__("Ignored unreadable document %r."),
+                                   filename, location=docname)
 
         return self.docnames
 
-    def path2doc(self, filename: str) -> str | None:
+    def path2doc(self, filename: str | os.PathLike[str]) -> str | None:
         """Return the docname for the filename if the file is a document.
 
         *filename* should be absolute or relative to the source directory.
         """
-        if filename.startswith(self.srcdir):
-            filename = relpath(filename, self.srcdir)
-        for suffix in self.source_suffix:
-            if filename.endswith(suffix):
-                filename = path_stabilize(filename)
-                return filename[:-len(suffix)]
+        try:
+            return self._path_to_docname[filename]  # type: ignore[index]
+        except KeyError:
+            if os.path.isabs(filename):
+                with contextlib.suppress(ValueError):
+                    filename = os.path.relpath(filename, self.srcdir)
+
+            for suffix in self.source_suffix:
+                if os.path.basename(filename).endswith(suffix):
+                    return path_stabilize(filename).removesuffix(suffix)
 
-        # the file does not have docname
-        return None
+            # the file does not have a docname
+            return None
 
-    def doc2path(self, docname: str, basedir: bool = True) -> str:
+    def doc2path(self, docname: str, absolute: bool) -> str:
         """Return the filename for the document name.
 
-        If *basedir* is True, return as an absolute path.
+        If *absolute* is True, return as an absolute path.
         Else, return as a relative path to the source directory.
         """
-        docname = docname.replace(SEP, os.path.sep)
-        basename = os.path.join(self.srcdir, docname)
-        for suffix in self.source_suffix:
-            if os.path.isfile(basename + suffix):
-                break
-        else:
-            # document does not exist
-            suffix = list(self.source_suffix)[0]
-
-        if basedir:
-            return basename + suffix
-        else:
-            return docname + suffix
+        try:
+            filename = self._docname_to_path[docname]
+        except KeyError:
+            # Backwards compatibility: the document does not exist
+            filename = docname + self._first_source_suffix
+
+        if absolute:
+            return os.path.join(self.srcdir, filename)
+        return filename

sphinx/pycode/__init__.py

@@ -138,7 +138,8 @@ class ModuleAnalyzer:
             self.tagorder = parser.deforders
             self._analyzed = True
         except Exception as exc:
-            raise PycodeError(f'parsing {self.srcname!r} failed: {exc!r}') from exc
+            msg = f'parsing {self.srcname!r} failed: {exc!r}'
+            raise PycodeError(msg) from exc
 
     def find_attr_docs(self) -> dict[tuple[str, str], list[str]]:
         """Find class and module-level attributes and their documentation."""

sphinx/pycode/ast.py

@@ -143,9 +143,6 @@ class _UnparseVisitor(ast.NodeVisitor):
         items = (k + ": " + v for k, v in zip(keys, values))
         return "{" + ", ".join(items) + "}"
 
-    def visit_Index(self, node: ast.Index) -> str:
-        return self.visit(node.value)
-
     def visit_Lambda(self, node: ast.Lambda) -> str:
         return "lambda %s: ..." % self.visit(node.args)
 
@@ -159,21 +156,18 @@ class _UnparseVisitor(ast.NodeVisitor):
         return "{" + ", ".join(self.visit(e) for e in node.elts) + "}"
 
     def visit_Subscript(self, node: ast.Subscript) -> str:
-        def is_simple_tuple(value: ast.AST) -> bool:
+        def is_simple_tuple(value: ast.expr) -> bool:
             return (
-                isinstance(value, ast.Tuple) and
-                bool(value.elts) and
-                not any(isinstance(elt, ast.Starred) for elt in value.elts)
+                isinstance(value, ast.Tuple)
+                and bool(value.elts)
+                and not any(isinstance(elt, ast.Starred) for elt in value.elts)
             )
 
         if is_simple_tuple(node.slice):
-            elts = ", ".join(self.visit(e) for e in node.slice.elts)  # type: ignore
-            return f"{self.visit(node.value)}[{elts}]"
-        elif isinstance(node.slice, ast.Index) and is_simple_tuple(node.slice.value):
-            elts = ", ".join(self.visit(e) for e in node.slice.value.elts)  # type: ignore
+            elts = ", ".join(self.visit(e)
+                             for e in node.slice.elts)  # type: ignore[attr-defined]
             return f"{self.visit(node.value)}[{elts}]"
-        else:
-            return f"{self.visit(node.value)}[{self.visit(node.slice)}]"
+        return f"{self.visit(node.value)}[{self.visit(node.slice)}]"
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> str:
         # UnaryOp is one of {UAdd, USub, Invert, Not}, which refer to ``+x``,

sphinx/pycode/parser.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ast
+import contextlib
 import inspect
 import itertools
 import re
@@ -28,7 +29,7 @@ def get_assign_targets(node: ast.AST) -> list[ast.expr]:
     if isinstance(node, ast.Assign):
         return node.targets
     else:
-        return [node.target]  # type: ignore
+        return [node.target]  # type: ignore[attr-defined]
 
 
 def get_lvar_names(node: ast.AST, self: ast.arg | None = None) -> list[str]:
@@ -44,20 +45,19 @@ def get_lvar_names(node: ast.AST, self: ast.arg | None = None) -> list[str]:
         self_id = self.arg
 
     node_name = node.__class__.__name__
-    if node_name in ('Index', 'Num', 'Slice', 'Str', 'Subscript'):
+    if node_name in ('Constant', 'Index', 'Slice', 'Subscript'):
         raise TypeError('%r does not create new variable' % node)
     if node_name == 'Name':
-        if self is None or node.id == self_id:  # type: ignore
-            return [node.id]  # type: ignore
+        if self is None or node.id == self_id:  # type: ignore[attr-defined]
+            return [node.id]  # type: ignore[attr-defined]
         else:
             raise TypeError('The assignment %r is not instance variable' % node)
     elif node_name in ('Tuple', 'List'):
         members = []
-        for elt in node.elts:  # type: ignore
-            try:
+        for elt in node.elts:  # type: ignore[attr-defined]
+            with contextlib.suppress(TypeError):
                 members.extend(get_lvar_names(elt, self))
-            except TypeError:
-                pass
+
         return members
     elif node_name == 'Attribute':
         if (
@@ -65,13 +65,13 @@ def get_lvar_names(node: ast.AST, self: ast.arg | None = None) -> list[str]:
             self and node.value.id == self_id  # type: ignore[attr-defined]
         ):
             # instance variable
-            return ["%s" % get_lvar_names(node.attr, self)[0]]  # type: ignore
+            return ["%s" % get_lvar_names(node.attr, self)[0]]  # type: ignore[attr-defined]
         else:
             raise TypeError('The assignment %r is not instance variable' % node)
     elif node_name == 'str':
-        return [node]  # type: ignore
+        return [node]  # type: ignore[list-item]
     elif node_name == 'Starred':
-        return get_lvar_names(node.value, self)  # type: ignore
+        return get_lvar_names(node.value, self)  # type: ignore[attr-defined]
     else:
         raise NotImplementedError('Unexpected node name %r' % node_name)
 
@@ -145,21 +145,21 @@ class TokenProcessor:
 
         return self.current
 
-    def fetch_until(self, condition: Any) -> list[Token | None]:
+    def fetch_until(self, condition: Any) -> list[Token]:
         """Fetch tokens until specified token appeared.
 
         .. note:: This also handles parenthesis well.
         """
         tokens = []
-        while self.fetch_token():
-            tokens.append(self.current)
-            if self.current == condition:
+        while current := self.fetch_token():
+            tokens.append(current)
+            if current == condition:
                 break
-            if self.current == [OP, '(']:
+            if current == [OP, '(']:
                 tokens += self.fetch_until([OP, ')'])
-            elif self.current == [OP, '{']:
+            elif current == [OP, '{']:
                 tokens += self.fetch_until([OP, '}'])
-            elif self.current == [OP, '[']:
+            elif current == [OP, '[']:
                 tokens += self.fetch_until([OP, ']'])
 
         return tokens
@@ -176,22 +176,22 @@ class AfterCommentParser(TokenProcessor):
         super().__init__(lines)
         self.comment: str | None = None
 
-    def fetch_rvalue(self) -> list[Token | None]:
+    def fetch_rvalue(self) -> list[Token]:
         """Fetch right-hand value of assignment."""
         tokens = []
-        while self.fetch_token():
-            tokens.append(self.current)
-            if self.current == [OP, '(']:
+        while current := self.fetch_token():
+            tokens.append(current)
+            if current == [OP, '(']:
                 tokens += self.fetch_until([OP, ')'])
-            elif self.current == [OP, '{']:
+            elif current == [OP, '{']:
                 tokens += self.fetch_until([OP, '}'])
-            elif self.current == [OP, '[']:
+            elif current == [OP, '[']:
                 tokens += self.fetch_until([OP, ']'])
-            elif self.current == INDENT:
+            elif current == INDENT:
                 tokens += self.fetch_until(DEDENT)
-            elif self.current == [OP, ';']:  # NoQA: SIM114
+            elif current == [OP, ';']:  # NoQA: SIM114
                 break
-            elif self.current and self.current.kind not in {OP, NAME, NUMBER, STRING}:
+            elif current and current.kind not in {OP, NAME, NUMBER, STRING}:
                 break
 
         return tokens
@@ -200,14 +200,17 @@ class AfterCommentParser(TokenProcessor):
         """Parse the code and obtain comment after assignment."""
         # skip lvalue (or whole of AnnAssign)
         while (tok := self.fetch_token()) and not tok.match([OP, '='], NEWLINE, COMMENT):
-            assert self.current
+            assert tok
+        assert tok is not None
 
         # skip rvalue (if exists)
-        if self.current == [OP, '=']:
+        if tok == [OP, '=']:
             self.fetch_rvalue()
+            tok = self.current
+            assert tok is not None
 
-        if self.current == COMMENT:
-            self.comment = self.current.value  # type: ignore[union-attr]
+        if tok == COMMENT:
+            self.comment = tok.value
 
 
 class VariableCommentPicker(ast.NodeVisitor):
@@ -360,7 +363,8 @@ class VariableCommentPicker(ast.NodeVisitor):
                 self.add_variable_annotation(varname, node.annotation)
         elif hasattr(node, 'type_comment') and node.type_comment:
             for varname in varnames:
-                self.add_variable_annotation(varname, node.type_comment)  # type: ignore
+                self.add_variable_annotation(
+                    varname, node.type_comment)  # type: ignore[arg-type]
 
         # check comments after assignment
         parser = AfterCommentParser([current_line[node.col_offset:]] +
@@ -395,20 +399,20 @@ class VariableCommentPicker(ast.NodeVisitor):
 
     def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
         """Handles AnnAssign node and pick up a variable comment."""
-        self.visit_Assign(node)  # type: ignore
+        self.visit_Assign(node)  # type: ignore[arg-type]
 
     def visit_Expr(self, node: ast.Expr) -> None:
         """Handles Expr node and pick up a comment if string."""
         if (isinstance(self.previous, (ast.Assign, ast.AnnAssign)) and
-                isinstance(node.value, ast.Str)):
+                isinstance(node.value, ast.Constant) and isinstance(node.value.value, str)):
             try:
                 targets = get_assign_targets(self.previous)
                 varnames = get_lvar_names(targets[0], self.get_self())
                 for varname in varnames:
-                    if isinstance(node.value.s, str):
-                        docstring = node.value.s
+                    if isinstance(node.value.value, str):
+                        docstring = node.value.value
                     else:
-                        docstring = node.value.s.decode(self.encoding or 'utf-8')
+                        docstring = node.value.value.decode(self.encoding or 'utf-8')
 
                     self.add_variable_comment(varname, dedent_docstring(docstring))
                     self.add_entry(varname)
@@ -455,7 +459,7 @@ class VariableCommentPicker(ast.NodeVisitor):
 
     def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
         """Handles AsyncFunctionDef node and set context."""
-        self.visit_FunctionDef(node)  # type: ignore
+        self.visit_FunctionDef(node)  # type: ignore[arg-type]
 
 
 class DefinitionFinder(TokenProcessor):

sphinx/registry.py

@@ -6,25 +6,15 @@ import sys
 import traceback
 from importlib import import_module
 from types import MethodType
-from typing import TYPE_CHECKING, Any, Callable, Iterator
-
-from docutils import nodes
-from docutils.core import Publisher
-from docutils.nodes import Element, Node, TextElement
-from docutils.parsers import Parser
-from docutils.parsers.rst import Directive
-from docutils.transforms import Transform
+from typing import TYPE_CHECKING, Any, Callable
 
 if sys.version_info >= (3, 10):
     from importlib.metadata import entry_points
 else:
     from importlib_metadata import entry_points
 
-from sphinx.builders import Builder
-from sphinx.config import Config
 from sphinx.domains import Domain, Index, ObjType
 from sphinx.domains.std import GenericObject, Target
-from sphinx.environment import BuildEnvironment
 from sphinx.errors import ExtensionError, SphinxError, VersionRequirementError
 from sphinx.extension import Extension
 from sphinx.io import create_publisher
@@ -33,11 +23,23 @@ from sphinx.parsers import Parser as SphinxParser
 from sphinx.roles import XRefRole
 from sphinx.util import logging
 from sphinx.util.logging import prefixed_warnings
-from sphinx.util.typing import RoleFunction, TitleGetter
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
+
+    from docutils import nodes
+    from docutils.core import Publisher
+    from docutils.nodes import Element, Node, TextElement
+    from docutils.parsers import Parser
+    from docutils.parsers.rst import Directive
+    from docutils.transforms import Transform
+
     from sphinx.application import Sphinx
+    from sphinx.builders import Builder
+    from sphinx.config import Config
+    from sphinx.environment import BuildEnvironment
     from sphinx.ext.autodoc import Documenter
+    from sphinx.util.typing import RoleFunction, TitleGetter
 
 logger = logging.getLogger(__name__)
 
@@ -83,12 +85,14 @@ class SphinxComponentRegistry:
 
         #: additional enumerable nodes
         #: a dict of node class -> tuple of figtype and title_getter function
-        self.enumerable_nodes: dict[type[Node], tuple[str, TitleGetter]] = {}
+        self.enumerable_nodes: dict[type[Node], tuple[str, TitleGetter | None]] = {}
 
         #: HTML inline and block math renderers
         #: a dict of name -> tuple of visit function and depart function
-        self.html_inline_math_renderers: dict[str, tuple[Callable, Callable]] = {}
-        self.html_block_math_renderers: dict[str, tuple[Callable, Callable]] = {}
+        self.html_inline_math_renderers: dict[str,
+                                              tuple[Callable, Callable | None]] = {}
+        self.html_block_math_renderers: dict[str,
+                                             tuple[Callable, Callable | None]] = {}
 
         #: HTML assets
         self.html_assets_policy: str = 'per_page'
@@ -97,12 +101,12 @@ class SphinxComponentRegistry:
         self.html_themes: dict[str, str] = {}
 
         #: js_files; list of JS paths or URLs
-        self.js_files: list[tuple[str, dict[str, Any]]] = []
+        self.js_files: list[tuple[str | None, dict[str, Any]]] = []
 
         #: LaTeX packages; list of package names and its options
-        self.latex_packages: list[tuple[str, str]] = []
+        self.latex_packages: list[tuple[str, str | None]] = []
 
-        self.latex_packages_after_hyperref: list[tuple[str, str]] = []
+        self.latex_packages_after_hyperref: list[tuple[str, str | None]] = []
 
         #: post transforms; list of transforms
         self.post_transforms: list[type[Transform]] = []
@@ -118,7 +122,7 @@ class SphinxComponentRegistry:
 
         #: custom handlers for translators
         #: a dict of builder name -> dict of node name -> visitor and departure functions
-        self.translation_handlers: dict[str, dict[str, tuple[Callable, Callable]]] = {}
+        self.translation_handlers: dict[str, dict[str, tuple[Callable, Callable | None]]] = {}
 
         #: additional transforms; list of transforms
         self.transforms: list[type[Transform]] = []
@@ -149,8 +153,7 @@ class SphinxComponentRegistry:
 
             self.load_extension(app, entry_point.module)
 
-    def create_builder(self, app: Sphinx, name: str,
-                       env: BuildEnvironment | None = None) -> Builder:
+    def create_builder(self, app: Sphinx, name: str, env: BuildEnvironment) -> Builder:
         if name not in self.builders:
             raise SphinxError(__('Builder name %s not registered') % name)
 
@@ -221,7 +224,7 @@ class SphinxComponentRegistry:
         parse_node: Callable | None = None,
         ref_nodeclass: type[TextElement] | None = None,
         objname: str = '',
-        doc_field_types: list = [],
+        doc_field_types: Sequence = (),
         override: bool = False,
     ) -> None:
         logger.debug('[app] adding object type: %r',
@@ -232,7 +235,7 @@ class SphinxComponentRegistry:
         directive = type(directivename,
                          (GenericObject, object),
                          {'indextemplate': indextemplate,
-                          'parse_node': staticmethod(parse_node),
+                          'parse_node': parse_node and staticmethod(parse_node),
                           'doc_field_types': doc_field_types})
 
         self.add_directive_to_domain('std', directivename, directive)
@@ -312,7 +315,7 @@ class SphinxComponentRegistry:
     def add_translation_handlers(
         self,
         node: type[Element],
-        **kwargs: tuple[Callable | None, Callable | None],
+        **kwargs: tuple[Callable, Callable | None],
     ) -> None:
         logger.debug('[app] adding translation_handlers: %r, %r', node, kwargs)
         for builder_name, handlers in kwargs.items():
@@ -333,7 +336,8 @@ class SphinxComponentRegistry:
             try:
                 return builder.default_translator_class
             except AttributeError as err:
-                raise AttributeError(f'translator not found for {builder.name}') from err
+                msg = f'translator not found for {builder.name}'
+                raise AttributeError(msg) from err
 
     def create_translator(self, builder: Builder, *args: Any) -> nodes.NodeVisitor:
         translator_class = self.get_translator_class(builder)
@@ -410,16 +414,18 @@ class SphinxComponentRegistry:
     def add_html_math_renderer(
         self,
         name: str,
-        inline_renderers: tuple[Callable | None, Callable | None] | None,
-        block_renderers: tuple[Callable | None, Callable | None] | None,
+        inline_renderers: tuple[Callable, Callable | None] | None,
+        block_renderers: tuple[Callable, Callable | None] | None,
     ) -> None:
         logger.debug('[app] adding html_math_renderer: %s, %r, %r',
                      name, inline_renderers, block_renderers)
         if name in self.html_inline_math_renderers:
             raise ExtensionError(__('math renderer %s is already registered') % name)
 
-        self.html_inline_math_renderers[name] = inline_renderers
-        self.html_block_math_renderers[name] = block_renderers
+        if inline_renderers is not None:
+            self.html_inline_math_renderers[name] = inline_renderers
+        if block_renderers is not None:
+            self.html_block_math_renderers[name] = block_renderers
 
     def add_html_theme(self, name: str, theme_path: str) -> None:
         self.html_themes[name] = theme_path

sphinx/roles.py

@@ -9,17 +9,20 @@ import docutils.parsers.rst.directives
 import docutils.parsers.rst.roles
 import docutils.parsers.rst.states
 from docutils import nodes, utils
-from docutils.nodes import Element, Node, TextElement, system_message
 
 from sphinx import addnodes
 from sphinx.locale import _, __
 from sphinx.util import ws_re
 from sphinx.util.docutils import ReferenceRole, SphinxRole
-from sphinx.util.typing import RoleFunction
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from docutils.nodes import Element, Node, TextElement, system_message
+
     from sphinx.application import Sphinx
     from sphinx.environment import BuildEnvironment
+    from sphinx.util.typing import RoleFunction
 
 
 generic_docroles = {
@@ -365,8 +368,10 @@ class Abbreviation(SphinxRole):
 # TODO: Change to use `SphinxRole` once SphinxRole is fixed to support options.
 def code_role(name: str, rawtext: str, text: str, lineno: int,
               inliner: docutils.parsers.rst.states.Inliner,
-              options: dict = {}, content: list[str] = [],
+              options: dict | None = None, content: Sequence[str] = (),
               ) -> tuple[list[Node], list[system_message]]:
+    if options is None:
+        options = {}
     options = options.copy()
     docutils.parsers.rst.roles.set_classes(options)
     language = options.get('language', '')
@@ -384,7 +389,7 @@ def code_role(name: str, rawtext: str, text: str, lineno: int,
     return [node], []
 
 
-code_role.options = {  # type: ignore
+code_role.options = {  # type: ignore[attr-defined]
     'class': docutils.parsers.rst.directives.class_option,
     'language': docutils.parsers.rst.directives.unchanged,
 }

sphinx/search/__init__.py

@@ -9,29 +9,17 @@ import pickle
 import re
 from importlib import import_module
 from os import path
-from typing import (
-    IO,
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
-    Union,
-)
+from typing import IO, TYPE_CHECKING, Any
 
 from docutils import nodes
 from docutils.nodes import Element, Node
 
 from sphinx import addnodes, package_dir
 from sphinx.environment import BuildEnvironment
-from sphinx.util import split_index_msg
+from sphinx.util.index_entries import split_index_msg
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 
 
 class SearchLanguage:

sphinx/search/da.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Dict
+from typing import TYPE_CHECKING, Dict
 
 import snowballstemmer