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

sphinx/domains/index.py

@@ -2,22 +2,26 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Iterable
+from typing import TYPE_CHECKING, Any
 
 from docutils import nodes
-from docutils.nodes import Node, system_message
 from docutils.parsers.rst import directives
 
 from sphinx import addnodes
 from sphinx.domains import Domain
-from sphinx.environment import BuildEnvironment
-from sphinx.util import logging, split_index_msg
+from sphinx.util import logging
 from sphinx.util.docutils import ReferenceRole, SphinxDirective
+from sphinx.util.index_entries import split_index_msg
 from sphinx.util.nodes import process_index_entry
-from sphinx.util.typing import OptionSpec
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from docutils.nodes import Node, system_message
+
     from sphinx.application import Sphinx
+    from sphinx.environment import BuildEnvironment
+    from sphinx.util.typing import OptionSpec
 
 
 logger = logging.getLogger(__name__)

sphinx/domains/javascript.py

@@ -2,32 +2,38 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterator, Tuple, cast
+import contextlib
+from typing import TYPE_CHECKING, Any, cast
 
 from docutils import nodes
-from docutils.nodes import Element, Node
 from docutils.parsers.rst import directives
 
 from sphinx import addnodes
-from sphinx.addnodes import desc_signature, pending_xref
-from sphinx.application import Sphinx
-from sphinx.builders import Builder
 from sphinx.directives import ObjectDescription
 from sphinx.domains import Domain, ObjType
 from sphinx.domains.python import _pseudo_parse_arglist
-from sphinx.environment import BuildEnvironment
 from sphinx.locale import _, __
 from sphinx.roles import XRefRole
 from sphinx.util import logging
 from sphinx.util.docfields import Field, GroupedField, TypedField
 from sphinx.util.docutils import SphinxDirective
 from sphinx.util.nodes import make_id, make_refnode, nested_parse_with_titles
-from sphinx.util.typing import OptionSpec
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from docutils.nodes import Element, Node
+
+    from sphinx.addnodes import desc_signature, pending_xref
+    from sphinx.application import Sphinx
+    from sphinx.builders import Builder
+    from sphinx.environment import BuildEnvironment
+    from sphinx.util.typing import OptionSpec
 
 logger = logging.getLogger(__name__)
 
 
-class JSObject(ObjectDescription[Tuple[str, str]]):
+class JSObject(ObjectDescription[tuple[str, str]]):
     """
     Description of a JavaScript object.
     """
@@ -40,6 +46,10 @@ class JSObject(ObjectDescription[Tuple[str, str]]):
     allow_nesting = False
 
     option_spec: OptionSpec = {
+        'no-index': directives.flag,
+        'no-index-entry': directives.flag,
+        'no-contents-entry': directives.flag,
+        'no-typesetting': directives.flag,
         'noindex': directives.flag,
         'noindexentry': directives.flag,
         'nocontentsentry': directives.flag,
@@ -142,7 +152,7 @@ class JSObject(ObjectDescription[Tuple[str, str]]):
         domain = cast(JavaScriptDomain, self.env.get_domain('js'))
         domain.note_object(fullname, self.objtype, node_id, location=signode)
 
-        if 'noindexentry' not in self.options:
+        if 'no-index-entry' not in self.options:
             indextext = self.get_index_text(mod_name, name_obj)  # type: ignore[arg-type]
             if indextext:
                 self.indexnode['entries'].append(('single', indextext, node_id, '', None))
@@ -209,10 +219,9 @@ class JSObject(ObjectDescription[Tuple[str, str]]):
         """
         objects = self.env.ref_context.setdefault('js:objects', [])
         if self.allow_nesting:
-            try:
+            with contextlib.suppress(IndexError):
                 objects.pop()
-            except IndexError:
-                pass
+
         self.env.ref_context['js:object'] = (objects[-1] if len(objects) > 0
                                              else None)
 
@@ -274,8 +283,8 @@ class JSModule(SphinxDirective):
     Options
     -------
 
-    noindex
-        If the ``noindex`` option is specified, no linkable elements will be
+    no-index
+        If the ``:no-index:`` option is specified, no linkable elements will be
         created, and the module won't be added to the global module index. This
         is useful for splitting up the module definition across multiple
         sections or files.
@@ -288,6 +297,9 @@ class JSModule(SphinxDirective):
     optional_arguments = 0
     final_argument_whitespace = False
     option_spec: OptionSpec = {
+        'no-index': directives.flag,
+        'no-contents-entry': directives.flag,
+        'no-typesetting': directives.flag,
         'noindex': directives.flag,
         'nocontentsentry': directives.flag,
     }
@@ -295,7 +307,7 @@ class JSModule(SphinxDirective):
     def run(self) -> list[Node]:
         mod_name = self.arguments[0].strip()
         self.env.ref_context['js:module'] = mod_name
-        noindex = 'noindex' in self.options
+        no_index = 'no-index' in self.options
 
         content_node: Element = nodes.section()
         # necessary so that the child nodes get the right source/line set
@@ -303,7 +315,7 @@ class JSModule(SphinxDirective):
         nested_parse_with_titles(self.state, self.content, content_node, self.content_offset)
 
         ret: list[Node] = []
-        if not noindex:
+        if not no_index:
             domain = cast(JavaScriptDomain, self.env.get_domain('js'))
 
             node_id = make_id(self.env, self.state.document, 'module', mod_name)
@@ -313,12 +325,13 @@ class JSModule(SphinxDirective):
             domain.note_object(mod_name, 'module', node_id,
                                location=(self.env.docname, self.lineno))
 
-            target = nodes.target('', '', ids=[node_id], ismod=True)
-            self.state.document.note_explicit_target(target)
-            ret.append(target)
+            # The node order is: index node first, then target node
             indextext = _('%s (module)') % mod_name
             inode = addnodes.index(entries=[('single', indextext, node_id, '', None)])
             ret.append(inode)
+            target = nodes.target('', '', ids=[node_id], ismod=True)
+            self.state.document.note_explicit_target(target)
+            ret.append(target)
         ret.extend(content_node.children)
         return ret
 

sphinx/domains/math.py

@@ -2,22 +2,24 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Iterable
+from typing import TYPE_CHECKING, Any
 
 from docutils import nodes
 from docutils.nodes import Element, Node, make_id, system_message
 
-from sphinx.addnodes import pending_xref
 from sphinx.domains import Domain
-from sphinx.environment import BuildEnvironment
 from sphinx.locale import __
 from sphinx.roles import XRefRole
 from sphinx.util import logging
 from sphinx.util.nodes import make_refnode
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from sphinx.addnodes import pending_xref
     from sphinx.application import Sphinx
     from sphinx.builders import Builder
+    from sphinx.environment import BuildEnvironment
 
 
 logger = logging.getLogger(__name__)

sphinx/domains/python.py

@@ -4,25 +4,21 @@ from __future__ import annotations
 
 import ast
 import builtins
+import contextlib
 import inspect
 import re
 import token
 import typing
 from inspect import Parameter
-from typing import Any, Iterable, Iterator, List, NamedTuple, Tuple, cast
+from typing import TYPE_CHECKING, Any, NamedTuple, cast
 
 from docutils import nodes
-from docutils.nodes import Element, Node
 from docutils.parsers.rst import directives
-from docutils.parsers.rst.states import Inliner
 
 from sphinx import addnodes
 from sphinx.addnodes import desc_signature, pending_xref, pending_xref_condition
-from sphinx.application import Sphinx
-from sphinx.builders import Builder
 from sphinx.directives import ObjectDescription
 from sphinx.domains import Domain, Index, IndexEntry, ObjType
-from sphinx.environment import BuildEnvironment
 from sphinx.locale import _, __
 from sphinx.pycode.parser import Token, TokenProcessor
 from sphinx.roles import XRefRole
@@ -36,7 +32,17 @@ from sphinx.util.nodes import (
     make_refnode,
     nested_parse_with_titles,
 )
-from sphinx.util.typing import OptionSpec, TextlikeNode
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
+    from docutils.nodes import Element, Node
+    from docutils.parsers.rst.states import Inliner
+
+    from sphinx.application import Sphinx
+    from sphinx.builders import Builder
+    from sphinx.environment import BuildEnvironment
+    from sphinx.util.typing import OptionSpec, TextlikeNode
 
 logger = logging.getLogger(__name__)
 
@@ -105,7 +111,7 @@ def parse_reftarget(reftarget: str, suppress_prefix: bool = False,
     return reftype, reftarget, title, refspecific
 
 
-def type_to_xref(target: str, env: BuildEnvironment | None = None,
+def type_to_xref(target: str, env: BuildEnvironment, *,
                  suppress_prefix: bool = False) -> addnodes.pending_xref:
     """Convert a type string to a cross reference node."""
     if env:
@@ -131,7 +137,7 @@ def type_to_xref(target: str, env: BuildEnvironment | None = None,
                         refspecific=refspecific, **kwargs)
 
 
-def _parse_annotation(annotation: str, env: BuildEnvironment | None) -> list[Node]:
+def _parse_annotation(annotation: str, env: BuildEnvironment) -> list[Node]:
     """Parse type annotation."""
     short_literals = env.config.python_display_short_literal_types
 
@@ -162,8 +168,6 @@ def _parse_annotation(annotation: str, env: BuildEnvironment | None) -> list[Nod
                 return [nodes.Text(repr(node.value))]
         if isinstance(node, ast.Expr):
             return unparse(node.value)
-        if isinstance(node, ast.Index):
-            return unparse(node.value)
         if isinstance(node, ast.Invert):
             return [addnodes.desc_sig_punctuation('', '~')]
         if isinstance(node, ast.List):
@@ -220,9 +224,6 @@ def _parse_annotation(annotation: str, env: BuildEnvironment | None) -> list[Nod
 
     def _unparse_pep_604_annotation(node: ast.Subscript) -> list[Node]:
         subscript = node.slice
-        if isinstance(subscript, ast.Index):
-            # py38 only
-            subscript = subscript.value  # type: ignore[assignment]
 
         flattened: list[Node] = []
         if isinstance(subscript, ast.Tuple):
@@ -271,25 +272,25 @@ class _TypeParameterListParser(TokenProcessor):
 
     def fetch_type_param_spec(self) -> list[Token]:
         tokens = []
-        while self.fetch_token():
-            tokens.append(self.current)
+        while current := self.fetch_token():
+            tokens.append(current)
             for ldelim, rdelim in ('(', ')'), ('{', '}'), ('[', ']'):
-                if self.current == [token.OP, ldelim]:
+                if current == [token.OP, ldelim]:
                     tokens += self.fetch_until([token.OP, rdelim])
                     break
             else:
-                if self.current == token.INDENT:
+                if current == token.INDENT:
                     tokens += self.fetch_until(token.DEDENT)
-                elif self.current.match(
+                elif current.match(
                         [token.OP, ':'], [token.OP, '='], [token.OP, ',']):
                     tokens.pop()
                     break
         return tokens
 
     def parse(self) -> None:
-        while self.fetch_token():
-            if self.current == token.NAME:
-                tp_name = self.current.value.strip()
+        while current := self.fetch_token():
+            if current == token.NAME:
+                tp_name = current.value.strip()
                 if self.previous and self.previous.match([token.OP, '*'], [token.OP, '**']):
                     if self.previous == [token.OP, '*']:
                         tp_kind = Parameter.VAR_POSITIONAL
@@ -301,19 +302,20 @@ class _TypeParameterListParser(TokenProcessor):
                 tp_ann: Any = Parameter.empty
                 tp_default: Any = Parameter.empty
 
-                self.fetch_token()
-                if self.current and self.current.match([token.OP, ':'], [token.OP, '=']):
-                    if self.current == [token.OP, ':']:
+                current = self.fetch_token()
+                if current and current.match([token.OP, ':'], [token.OP, '=']):
+                    if current == [token.OP, ':']:
                         tokens = self.fetch_type_param_spec()
                         tp_ann = self._build_identifier(tokens)
 
-                    if self.current == [token.OP, '=']:
+                    if self.current and self.current == [token.OP, '=']:
                         tokens = self.fetch_type_param_spec()
                         tp_default = self._build_identifier(tokens)
 
                 if tp_kind != Parameter.POSITIONAL_OR_KEYWORD and tp_ann != Parameter.empty:
-                    raise SyntaxError('type parameter bound or constraint is not allowed '
-                                      f'for {tp_kind.description} parameters')
+                    msg = ('type parameter bound or constraint is not allowed '
+                           f'for {tp_kind.description} parameters')
+                    raise SyntaxError(msg)
 
                 type_param = (tp_name, tp_kind, tp_default, tp_ann)
                 self.type_params.append(type_param)
@@ -331,7 +333,7 @@ class _TypeParameterListParser(TokenProcessor):
                 yield a, b, c
 
         idents: list[str] = []
-        tokens: Iterable[Token] = iter(tokens)  # type: ignore
+        tokens: Iterable[Token] = iter(tokens)  # type: ignore[no-redef]
         # do not format opening brackets
         for tok in tokens:
             if not tok.match([token.OP, '('], [token.OP, '['], [token.OP, '{']):
@@ -397,7 +399,7 @@ class _TypeParameterListParser(TokenProcessor):
 
 
 def _parse_type_list(
-    tp_list: str, env: BuildEnvironment | None = None,
+    tp_list: str, env: BuildEnvironment,
     multi_line_parameter_list: bool = False,
 ) -> addnodes.desc_type_parameter_list:
     """Parse a list of type parameters according to PEP 695."""
@@ -410,8 +412,9 @@ def _parse_type_list(
     for (tp_name, tp_kind, tp_default, tp_ann) in parser.type_params:
         # no positional-only or keyword-only allowed in a type parameters list
         if tp_kind in {Parameter.POSITIONAL_ONLY, Parameter.KEYWORD_ONLY}:
-            raise SyntaxError('positional-only or keyword-only parameters'
-                              ' are prohibited in type parameter lists')
+            msg = ('positional-only or keyword-only parameters '
+                   'are prohibited in type parameter lists')
+            raise SyntaxError(msg)
 
         node = addnodes.desc_type_parameter()
         if tp_kind == Parameter.VAR_POSITIONAL:
@@ -458,7 +461,7 @@ def _parse_type_list(
 
 
 def _parse_arglist(
-    arglist: str, env: BuildEnvironment | None = None, multi_line_parameter_list: bool = False,
+    arglist: str, env: BuildEnvironment, multi_line_parameter_list: bool = False,
 ) -> addnodes.desc_parameterlist:
     """Parse a list of arguments using AST parser"""
     params = addnodes.desc_parameterlist(arglist)
@@ -489,7 +492,7 @@ def _parse_arglist(
             children = _parse_annotation(param.annotation, env)
             node += addnodes.desc_sig_punctuation('', ':')
             node += addnodes.desc_sig_space()
-            node += addnodes.desc_sig_name('', '', *children)  # type: ignore
+            node += addnodes.desc_sig_name('', '', *children)  # type: ignore[arg-type]
         if param.default is not param.empty:
             if param.annotation is not param.empty:
                 node += addnodes.desc_sig_space()
@@ -578,10 +581,11 @@ class PyXrefMixin:
     ) -> Node:
         # we use inliner=None to make sure we get the old behaviour with a single
         # pending_xref node
-        result = super().make_xref(rolename, domain, target,  # type: ignore
+        result = super().make_xref(rolename, domain, target,  # type: ignore[misc]
                                    innernode, contnode,
                                    env, inliner=None, location=None)
         if isinstance(result, pending_xref):
+            assert env is not None
             result['refspecific'] = True
             result['py:module'] = env.ref_context.get('py:module')
             result['py:class'] = env.ref_context.get('py:class')
@@ -652,7 +656,7 @@ class PyTypedField(PyXrefMixin, TypedField):
     pass
 
 
-class PyObject(ObjectDescription[Tuple[str, str]]):
+class PyObject(ObjectDescription[tuple[str, str]]):
     """
     Description of a general Python object.
 
@@ -660,6 +664,10 @@ class PyObject(ObjectDescription[Tuple[str, str]]):
     :vartype allow_nesting: bool
     """
     option_spec: OptionSpec = {
+        'no-index': directives.flag,
+        'no-index-entry': directives.flag,
+        'no-contents-entry': directives.flag,
+        'no-typesetting': directives.flag,
         'noindex': directives.flag,
         'noindexentry': directives.flag,
         'nocontentsentry': directives.flag,
@@ -771,10 +779,10 @@ class PyObject(ObjectDescription[Tuple[str, str]]):
         sig_prefix = self.get_signature_prefix(sig)
         if sig_prefix:
             if type(sig_prefix) is str:
-                raise TypeError(
-                    "Python directive method get_signature_prefix()"
-                    " must return a list of nodes."
-                    f" Return value was '{sig_prefix}'.")
+                msg = ("Python directive method get_signature_prefix()"
+                       " must return a list of nodes."
+                       f" Return value was '{sig_prefix}'.")
+                raise TypeError(msg)
             signode += addnodes.desc_annotation(str(sig_prefix), '', *sig_prefix)
 
         if prefix:
@@ -836,7 +844,8 @@ class PyObject(ObjectDescription[Tuple[str, str]]):
 
     def get_index_text(self, modname: str, name: tuple[str, str]) -> str:
         """Return the text for the index entry of the object."""
-        raise NotImplementedError('must be implemented in subclasses')
+        msg = 'must be implemented in subclasses'
+        raise NotImplementedError(msg)
 
     def add_target_and_index(self, name_cls: tuple[str, str], sig: str,
                              signode: desc_signature) -> None:
@@ -854,7 +863,7 @@ class PyObject(ObjectDescription[Tuple[str, str]]):
             domain.note_object(canonical_name, self.objtype, node_id, aliased=True,
                                location=signode)
 
-        if 'noindexentry' not in self.options:
+        if 'no-index-entry' not in self.options:
             indextext = self.get_index_text(modname, name_cls)
             if indextext:
                 self.indexnode['entries'].append(('single', indextext, node_id, '', None))
@@ -904,10 +913,9 @@ class PyObject(ObjectDescription[Tuple[str, str]]):
         """
         classes = self.env.ref_context.setdefault('py:classes', [])
         if self.allow_nesting:
-            try:
+            with contextlib.suppress(IndexError):
                 classes.pop()
-            except IndexError:
-                pass
+
         self.env.ref_context['py:class'] = (classes[-1] if len(classes) > 0
                                             else None)
         if 'module' in self.options:
@@ -958,7 +966,7 @@ class PyFunction(PyObject):
     def add_target_and_index(self, name_cls: tuple[str, str], sig: str,
                              signode: desc_signature) -> None:
         super().add_target_and_index(name_cls, sig, signode)
-        if 'noindexentry' not in self.options:
+        if 'no-index-entry' not in self.options:
             modname = self.options.get('module', self.env.ref_context.get('py:module'))
             node_id = signode['ids'][0]
 
@@ -970,9 +978,9 @@ class PyFunction(PyObject):
                 text = f'built-in function; {name}()'
                 self.indexnode['entries'].append(('pair', text, node_id, '', None))
 
-    def get_index_text(self, modname: str, name_cls: tuple[str, str]) -> str | None:
+    def get_index_text(self, modname: str, name_cls: tuple[str, str]) -> str:
         # add index in own add_target_and_index() instead.
-        return None
+        return ''
 
 
 class PyDecoratorFunction(PyFunction):
@@ -1261,6 +1269,9 @@ class PyModule(SphinxDirective):
     option_spec: OptionSpec = {
         'platform': lambda x: x,
         'synopsis': lambda x: x,
+        'no-index': directives.flag,
+        'no-contents-entry': directives.flag,
+        'no-typesetting': directives.flag,
         'noindex': directives.flag,
         'nocontentsentry': directives.flag,
         'deprecated': directives.flag,
@@ -1270,7 +1281,7 @@ class PyModule(SphinxDirective):
         domain = cast(PythonDomain, self.env.get_domain('py'))
 
         modname = self.arguments[0].strip()
-        noindex = 'noindex' in self.options
+        no_index = 'no-index' in self.options
         self.env.ref_context['py:module'] = modname
 
         content_node: Element = nodes.section()
@@ -1279,7 +1290,7 @@ class PyModule(SphinxDirective):
         nested_parse_with_titles(self.state, self.content, content_node, self.content_offset)
 
         ret: list[Node] = []
-        if not noindex:
+        if not no_index:
             # note module to the domain
             node_id = make_id(self.env, self.state.document, 'module', modname)
             target = nodes.target('', '', ids=[node_id], ismod=True)
@@ -1295,10 +1306,11 @@ class PyModule(SphinxDirective):
 
             # the platform and synopsis aren't printed; in fact, they are only
             # used in the modindex currently
-            ret.append(target)
             indextext = f'module; {modname}'
             inode = addnodes.index(entries=[('pair', indextext, node_id, '', None)])
+            # The node order is: index node first, then target node.
             ret.append(inode)
+            ret.append(target)
         ret.extend(content_node.children)
         return ret
 
@@ -1354,7 +1366,7 @@ def filter_meta_fields(app: Sphinx, domain: str, objtype: str, content: Element)
 
     for node in content:
         if isinstance(node, nodes.field_list):
-            fields = cast(List[nodes.field], node)
+            fields = cast(list[nodes.field], node)
             # removing list items while iterating the list needs reversed()
             for field in reversed(fields):
                 field_name = cast(nodes.field_body, field[0]).astext().strip()
@@ -1506,7 +1518,7 @@ class PythonDomain(Domain):
             else:
                 # duplicated
                 logger.warning(__('duplicate object description of %s, '
-                                  'other instance in %s, use :noindex: for one of them'),
+                                  'other instance in %s, use :no-index: for one of them'),
                                name, other.docname, location=location)
         self.objects[name] = ObjectEntry(self.env.docname, node_id, objtype, aliased)
 
@@ -1558,7 +1570,7 @@ class PythonDomain(Domain):
         newname = None
         if searchmode == 1:
             if type is None:
-                objtypes = list(self.object_types)
+                objtypes: list[str] | None = list(self.object_types)
             else:
                 objtypes = self.objtypes_for_role(type)
             if objtypes is not None:
@@ -1673,9 +1685,9 @@ class PythonDomain(Domain):
                     # if not found, use contnode
                     children = [contnode]
 
-                results.append(('py:' + self.role_for_objtype(obj[2]),
-                                make_refnode(builder, fromdocname, obj[0], obj[1],
-                                             children, name)))
+                role = 'py:' + self.role_for_objtype(obj[2])  # type: ignore[operator]
+                results.append((role, make_refnode(builder, fromdocname, obj[0], obj[1],
+                                                   children, name)))
         return results
 
     def _make_module_refnode(self, builder: Builder, fromdocname: str, name: str,

sphinx/domains/rst.py

@@ -3,23 +3,28 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Iterator, cast
+from typing import TYPE_CHECKING, Any, cast
 
-from docutils.nodes import Element
 from docutils.parsers.rst import directives
 
 from sphinx import addnodes
-from sphinx.addnodes import desc_signature, pending_xref
-from sphinx.application import Sphinx
-from sphinx.builders import Builder
 from sphinx.directives import ObjectDescription
 from sphinx.domains import Domain, ObjType
-from sphinx.environment import BuildEnvironment
 from sphinx.locale import _, __
 from sphinx.roles import XRefRole
 from sphinx.util import logging
 from sphinx.util.nodes import make_id, make_refnode
-from sphinx.util.typing import OptionSpec
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from docutils.nodes import Element
+
+    from sphinx.addnodes import desc_signature, pending_xref
+    from sphinx.application import Sphinx
+    from sphinx.builders import Builder
+    from sphinx.environment import BuildEnvironment
+    from sphinx.util.typing import OptionSpec
 
 logger = logging.getLogger(__name__)
 
@@ -31,6 +36,10 @@ class ReSTMarkup(ObjectDescription[str]):
     Description of generic reST markup.
     """
     option_spec: OptionSpec = {
+        'no-index': directives.flag,
+        'no-index-entry': directives.flag,
+        'no-contents-entry': directives.flag,
+        'no-typesetting': directives.flag,
         'noindex': directives.flag,
         'noindexentry': directives.flag,
         'nocontentsentry': directives.flag,
@@ -44,7 +53,7 @@ class ReSTMarkup(ObjectDescription[str]):
         domain = cast(ReSTDomain, self.env.get_domain('rst'))
         domain.note_object(self.objtype, name, node_id, location=signode)
 
-        if 'noindexentry' not in self.options:
+        if 'no-index-entry' not in self.options:
             indextext = self.get_index_text(self.objtype, name)
             if indextext:
                 self.indexnode['entries'].append(('single', indextext, node_id, '', None))
@@ -137,7 +146,7 @@ class ReSTDirectiveOption(ReSTMarkup):
 
     def handle_signature(self, sig: str, signode: desc_signature) -> str:
         try:
-            name, argument = re.split(r'\s*:\s+', sig.strip(), 1)
+            name, argument = re.split(r'\s*:\s+', sig.strip(), maxsplit=1)
         except ValueError:
             name, argument = sig, None
 
@@ -206,9 +215,9 @@ class ReSTDomain(Domain):
     label = 'reStructuredText'
 
     object_types = {
-        'directive':        ObjType(_('directive'), 'dir'),
+        'directive':        ObjType(_('directive'),        'dir'),
         'directive:option': ObjType(_('directive-option'), 'dir'),
-        'role':             ObjType(_('role'),      'role'),
+        'role':             ObjType(_('role'),             'role'),
     }
     directives = {
         'directive': ReSTDirective,