Sphinx 7.2.5__py3-none-any.whl → 7.3.0__py3-none-any.whl

sphinx/parsers.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 import docutils.parsers
 import docutils.parsers.rst
@@ -19,6 +19,7 @@ if TYPE_CHECKING:
     from sphinx.application import Sphinx
     from sphinx.config import Config
     from sphinx.environment import BuildEnvironment
+    from sphinx.util.typing import ExtensionMetadata
 
 
 class Parser(docutils.parsers.Parser):
@@ -65,13 +66,14 @@ class RSTParser(docutils.parsers.rst.Parser, Parser):
         self.statemachine = states.RSTStateMachine(
             state_classes=self.state_classes,
             initial_state=self.initial_state,
-            debug=document.reporter.debug_flag)
+            debug=document.reporter.debug_flag,
+        )
 
         # preprocess inputstring
         if isinstance(inputstring, str):
             lines = docutils.statemachine.string2lines(
-                inputstring, tab_width=document.settings.tab_width,
-                convert_whitespace=True)
+                inputstring, tab_width=document.settings.tab_width, convert_whitespace=True
+            )
 
             inputlines = StringList(lines, document.current_source)
         else:
@@ -87,7 +89,7 @@ class RSTParser(docutils.parsers.rst.Parser, Parser):
         append_epilog(content, self.config.rst_epilog)
 
 
-def setup(app: Sphinx) -> dict[str, Any]:
+def setup(app: Sphinx) -> ExtensionMetadata:
     app.add_source_parser(RSTParser)
 
     return {

sphinx/project.py

@@ -28,7 +28,7 @@ class Project:
 
         #: source_suffix. Same as :confval:`source_suffix`.
         self.source_suffix = tuple(source_suffix)
-        self._first_source_suffix = next(iter(self.source_suffix), "")
+        self._first_source_suffix = next(iter(self.source_suffix), '')
 
         #: The name of documents belonging to this project.
         self.docnames: set[str] = set()
@@ -43,12 +43,12 @@ class Project:
         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]:
+    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.clear()
         self._path_to_docname.clear()
         self._docname_to_path.clear()
@@ -56,23 +56,30 @@ class Project:
         for filename in get_matching_files(
             self.srcdir,
             include_paths,
-            [*exclude_paths] + EXCLUDE_PATHS,
+            [*exclude_paths, *EXCLUDE_PATHS],
         ):
             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, absolute=True),
-                                   once=True)
+                    logger.warning(
+                        __(
+                            'multiple files found for the document "%s": %r\n'
+                            'Use %r for the build.'
+                        ),
+                        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(__("Ignored unreadable document %r."),
-                                   filename, location=docname)
+                    logger.warning(
+                        __('Ignored unreadable document %r.'), filename, location=docname
+                    )
 
         return self.docnames
 

sphinx/pycode/__init__.py

@@ -69,12 +69,13 @@ class ModuleAnalyzer:
         return filename, None
 
     @classmethod
-    def for_string(cls, string: str, modname: str, srcname: str = '<string>',
-                   ) -> ModuleAnalyzer:
+    def for_string(
+        cls: type[ModuleAnalyzer], string: str, modname: str, srcname: str = '<string>',
+    ) -> ModuleAnalyzer:
         return cls(string, modname, srcname)
 
     @classmethod
-    def for_file(cls, filename: str, modname: str) -> ModuleAnalyzer:
+    def for_file(cls: type[ModuleAnalyzer], filename: str, modname: str) -> ModuleAnalyzer:
         if ('file', filename) in cls.cache:
             return cls.cache['file', filename]
         try:
@@ -87,7 +88,7 @@ class ModuleAnalyzer:
         return obj
 
     @classmethod
-    def for_module(cls, modname: str) -> ModuleAnalyzer:
+    def for_module(cls: type[ModuleAnalyzer], modname: str) -> ModuleAnalyzer:
         if ('module', modname) in cls.cache:
             entry = cls.cache['module', modname]
             if isinstance(entry, PycodeError):
@@ -127,7 +128,7 @@ class ModuleAnalyzer:
             self.attr_docs = {}
             for (scope, comment) in parser.comments.items():
                 if comment:
-                    self.attr_docs[scope] = comment.splitlines() + ['']
+                    self.attr_docs[scope] = [*comment.splitlines(), '']
                 else:
                     self.attr_docs[scope] = ['']
 

sphinx/pycode/ast.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import ast
-from typing import overload
+from typing import NoReturn, overload
 
 OPERATORS: dict[type[ast.AST], str] = {
     ast.Add: "+",
@@ -85,9 +85,8 @@ class _UnparseVisitor(ast.NodeVisitor):
         for _ in range(len(kw_defaults), len(node.kwonlyargs)):
             kw_defaults.insert(0, None)
 
-        args: list[str] = []
-        for i, arg in enumerate(node.posonlyargs):
-            args.append(self._visit_arg_with_default(arg, defaults[i]))
+        args: list[str] = [self._visit_arg_with_default(arg, defaults[i])
+                           for i, arg in enumerate(node.posonlyargs)]
 
         if node.posonlyargs:
             args.append('/')
@@ -115,15 +114,17 @@ class _UnparseVisitor(ast.NodeVisitor):
         # Special case ``**`` to not have surrounding spaces.
         if isinstance(node.op, ast.Pow):
             return "".join(map(self.visit, (node.left, node.op, node.right)))
-        return " ".join(self.visit(e) for e in [node.left, node.op, node.right])
+        return " ".join(map(self.visit, (node.left, node.op, node.right)))
 
     def visit_BoolOp(self, node: ast.BoolOp) -> str:
         op = " %s " % self.visit(node.op)
         return op.join(self.visit(e) for e in node.values)
 
     def visit_Call(self, node: ast.Call) -> str:
-        args = ', '.join([self.visit(e) for e in node.args]
-                         + [f"{k.arg}={self.visit(k.value)}" for k in node.keywords])
+        args = ', '.join(
+            [self.visit(e) for e in node.args]
+            + [f"{k.arg}={self.visit(k.value)}" for k in node.keywords],
+        )
         return f"{self.visit(node.func)}({args})"
 
     def visit_Constant(self, node: ast.Constant) -> str:
@@ -155,6 +156,20 @@ class _UnparseVisitor(ast.NodeVisitor):
     def visit_Set(self, node: ast.Set) -> str:
         return "{" + ", ".join(self.visit(e) for e in node.elts) + "}"
 
+    def visit_Slice(self, node: ast.Slice) -> str:
+        if not node.lower and not node.upper and not node.step:
+            # Empty slice with default values -> [:]
+            return ":"
+
+        start = self.visit(node.lower) if node.lower else ""
+        stop = self.visit(node.upper) if node.upper else ""
+        if not node.step:
+            # Default step size -> [start:stop]
+            return f"{start}:{stop}"
+
+        step = self.visit(node.step) if node.step else ""
+        return f"{start}:{stop}:{step}"
+
     def visit_Subscript(self, node: ast.Subscript) -> str:
         def is_simple_tuple(value: ast.expr) -> bool:
             return (
@@ -184,5 +199,5 @@ class _UnparseVisitor(ast.NodeVisitor):
         else:
             return "(" + ", ".join(self.visit(e) for e in node.elts) + ")"
 
-    def generic_visit(self, node):
+    def generic_visit(self, node: ast.AST) -> NoReturn:
         raise NotImplementedError('Unable to parse %s object' % type(node).__name__)

sphinx/pycode/parser.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 
 import ast
 import contextlib
+import functools
 import inspect
 import itertools
+import operator
 import re
 import tokenize
 from inspect import Signature
@@ -243,7 +245,7 @@ class VariableCommentPicker(ast.NodeVisitor):
             else:
                 return None
         else:
-            return self.context + [name]
+            return [*self.context, name]
 
     def add_entry(self, name: str) -> None:
         qualname = self.get_qualname_for(name)
@@ -350,9 +352,8 @@ class VariableCommentPicker(ast.NodeVisitor):
         """Handles Assign node and pick up a variable comment."""
         try:
             targets = get_assign_targets(node)
-            varnames: list[str] = sum(
-                [get_lvar_names(t, self=self.get_self()) for t in targets], [],
-            )
+            varnames: list[str] = functools.reduce(
+                operator.iadd, [get_lvar_names(t, self=self.get_self()) for t in targets], [])
             current_line = self.get_line(node.lineno)
         except TypeError:
             return  # this assignment is not new definition!
@@ -476,7 +477,7 @@ class DefinitionFinder(TokenProcessor):
 
     def add_definition(self, name: str, entry: tuple[str, int, int]) -> None:
         """Add a location of definition."""
-        if self.indents and self.indents[-1][0] == 'def' and entry[0] == 'def':
+        if self.indents and self.indents[-1][0] == entry[0] == 'def':
             # ignore definition of inner function
             pass
         else:

sphinx/registry.py

@@ -39,7 +39,12 @@ if TYPE_CHECKING:
     from sphinx.config import Config
     from sphinx.environment import BuildEnvironment
     from sphinx.ext.autodoc import Documenter
-    from sphinx.util.typing import RoleFunction, TitleGetter
+    from sphinx.util.typing import (
+        ExtensionMetadata,
+        RoleFunction,
+        TitleGetter,
+        _ExtensionSetupFunc,
+    )
 
 logger = logging.getLogger(__name__)
 
@@ -47,6 +52,7 @@ logger = logging.getLogger(__name__)
 # Values are Sphinx version that merge the extension.
 EXTENSION_BLACKLIST = {
     "sphinxjp.themecore": "1.2",
+    "sphinxprettysearchresults": "2.0.0",
 }
 
 
@@ -55,7 +61,7 @@ class SphinxComponentRegistry:
         #: special attrgetter for autodoc; class object -> attrgetter
         self.autodoc_attrgettrs: dict[type, Callable[[Any, str, Any], Any]] = {}
 
-        #: builders; a dict of builder name -> bulider class
+        #: builders; a dict of builder name -> builder class
         self.builders: dict[str, type[Builder]] = {}
 
         #: autodoc documenters; a dict of documenter name -> documenter class
@@ -450,11 +456,11 @@ class SphinxComponentRegistry:
                 raise ExtensionError(__('Could not import extension %s') % extname,
                                      err) from err
 
-            setup = getattr(mod, 'setup', None)
+            setup: _ExtensionSetupFunc | None = getattr(mod, 'setup', None)
             if setup is None:
                 logger.warning(__('extension %r has no setup() function; is it really '
                                   'a Sphinx extension module?'), extname)
-                metadata: dict[str, Any] = {}
+                metadata: ExtensionMetadata = {}
             else:
                 try:
                     metadata = setup(app)
@@ -476,7 +482,7 @@ class SphinxComponentRegistry:
 
             app.extensions[extname] = Extension(extname, mod, **metadata)
 
-    def get_envversion(self, app: Sphinx) -> dict[str, str]:
+    def get_envversion(self, app: Sphinx) -> dict[str, int]:
         from sphinx.environment import ENV_VERSION
         envversion = {ext.name: ext.metadata['env_version'] for ext in app.extensions.values()
                       if ext.metadata.get('env_version')}
@@ -507,7 +513,7 @@ def merge_source_suffix(app: Sphinx, config: Config) -> None:
     app.registry.source_suffix = app.config.source_suffix
 
 
-def setup(app: Sphinx) -> dict[str, Any]:
+def setup(app: Sphinx) -> ExtensionMetadata:
     app.connect('config-inited', merge_source_suffix, priority=800)
 
     return {

sphinx/roles.py

@@ -22,7 +22,7 @@ if TYPE_CHECKING:
 
     from sphinx.application import Sphinx
     from sphinx.environment import BuildEnvironment
-    from sphinx.util.typing import RoleFunction
+    from sphinx.util.typing import ExtensionMetadata, RoleFunction
 
 
 generic_docroles = {
@@ -31,7 +31,6 @@ generic_docroles = {
     'kbd': nodes.literal,
     'mailheader': addnodes.literal_emphasis,
     'makevar': addnodes.literal_strong,
-    'manpage': addnodes.manpage,
     'mimetype': addnodes.literal_emphasis,
     'newsgroup': addnodes.literal_emphasis,
     'program': addnodes.literal_strong,  # XXX should be an x-ref
@@ -41,6 +40,7 @@ generic_docroles = {
 
 # -- generic cross-reference role ----------------------------------------------
 
+
 class XRefRole(ReferenceRole):
     """
     A generic cross-referencing role.  To create a callable that can be used as
@@ -68,10 +68,14 @@ class XRefRole(ReferenceRole):
     nodeclass: type[Element] = addnodes.pending_xref
     innernodeclass: type[TextElement] = nodes.literal
 
-    def __init__(self, fix_parens: bool = False, lowercase: bool = False,
-                 nodeclass: type[Element] | None = None,
-                 innernodeclass: type[TextElement] | None = None,
-                 warn_dangling: bool = False) -> None:
+    def __init__(
+        self,
+        fix_parens: bool = False,
+        lowercase: bool = False,
+        nodeclass: type[Element] | None = None,
+        innernodeclass: type[TextElement] | None = None,
+        warn_dangling: bool = False,
+    ) -> None:
         self.fix_parens = fix_parens
         self.lowercase = lowercase
         self.warn_dangling = warn_dangling
@@ -112,7 +116,7 @@ class XRefRole(ReferenceRole):
         text = utils.unescape(self.text[1:])
         if self.fix_parens:
             self.has_explicit_title = False  # treat as implicit
-            text, target = self.update_title_and_target(text, "")
+            text, target = self.update_title_and_target(text, '')
 
         node = self.innernodeclass(self.rawtext, text, classes=self.classes)
         return self.result_nodes(self.inliner.document, self.env, node, is_ref=False)
@@ -126,17 +130,20 @@ class XRefRole(ReferenceRole):
             title, target = self.update_title_and_target(title, target)
 
         # create the reference node
-        options = {'refdoc': self.env.docname,
-                   'refdomain': self.refdomain,
-                   'reftype': self.reftype,
-                   'refexplicit': self.has_explicit_title,
-                   'refwarn': self.warn_dangling}
+        options = {
+            'refdoc': self.env.docname,
+            'refdomain': self.refdomain,
+            'reftype': self.reftype,
+            'refexplicit': self.has_explicit_title,
+            'refwarn': self.warn_dangling,
+        }
         refnode = self.nodeclass(self.rawtext, **options)
         self.set_source_info(refnode)
 
         # determine the target and title for the class
-        title, target = self.process_link(self.env, refnode, self.has_explicit_title,
-                                          title, target)
+        title, target = self.process_link(
+            self.env, refnode, self.has_explicit_title, title, target
+        )
         refnode['reftarget'] = target
         refnode += self.innernodeclass(self.rawtext, title, classes=self.classes)
 
@@ -144,8 +151,14 @@ class XRefRole(ReferenceRole):
 
     # methods that can be overwritten
 
-    def process_link(self, env: BuildEnvironment, refnode: Element, has_explicit_title: bool,
-                     title: str, target: str) -> tuple[str, str]:
+    def process_link(
+        self,
+        env: BuildEnvironment,
+        refnode: Element,
+        has_explicit_title: bool,
+        title: str,
+        target: str,
+    ) -> tuple[str, str]:
         """Called after parsing title and target text, and creating the
         reference node (given in *refnode*).  This method can alter the
         reference node and must return a new (or the same) ``(title, target)``
@@ -153,8 +166,9 @@ class XRefRole(ReferenceRole):
         """
         return title, ws_re.sub(' ', target)
 
-    def result_nodes(self, document: nodes.document, env: BuildEnvironment, node: Element,
-                     is_ref: bool) -> tuple[list[Node], list[system_message]]:
+    def result_nodes(
+        self, document: nodes.document, env: BuildEnvironment, node: Element, is_ref: bool
+    ) -> tuple[list[Node], list[system_message]]:
         """Called before returning the finished nodes.  *node* is the reference
         node if one was created (*is_ref* is then true), else the content node.
         This method can add other nodes and must return a ``(nodes, messages)``
@@ -164,8 +178,14 @@ class XRefRole(ReferenceRole):
 
 
 class AnyXRefRole(XRefRole):
-    def process_link(self, env: BuildEnvironment, refnode: Element, has_explicit_title: bool,
-                     title: str, target: str) -> tuple[str, str]:
+    def process_link(
+        self,
+        env: BuildEnvironment,
+        refnode: Element,
+        has_explicit_title: bool,
+        title: str,
+        target: str,
+    ) -> tuple[str, str]:
         result = super().process_link(env, refnode, has_explicit_title, title, target)
         # add all possible context info (i.e. std:program, py:module etc.)
         refnode.attributes.update(env.ref_context)
@@ -175,8 +195,15 @@ class AnyXRefRole(XRefRole):
 class PEP(ReferenceRole):
     def run(self) -> tuple[list[Node], list[system_message]]:
         target_id = 'index-%s' % self.env.new_serialno('index')
-        entries = [('single', _('Python Enhancement Proposals; PEP %s') % self.target,
-                    target_id, '', None)]
+        entries = [
+            (
+                'single',
+                _('Python Enhancement Proposals; PEP %s') % self.target,
+                target_id,
+                '',
+                None,
+            )
+        ]
 
         index = addnodes.index(entries=entries)
         target = nodes.target('', '', ids=[target_id])
@@ -188,11 +215,12 @@ class PEP(ReferenceRole):
             if self.has_explicit_title:
                 reference += nodes.strong(self.title, self.title)
             else:
-                title = "PEP " + self.title
+                title = 'PEP ' + self.title
                 reference += nodes.strong(title, title)
         except ValueError:
-            msg = self.inliner.reporter.error(__('invalid PEP number %s') % self.target,
-                                              line=self.lineno)
+            msg = self.inliner.reporter.error(
+                __('invalid PEP number %s') % self.target, line=self.lineno
+            )
             prb = self.inliner.problematic(self.rawtext, self.rawtext, msg)
             return [prb], [msg]
 
@@ -222,11 +250,12 @@ class RFC(ReferenceRole):
             if self.has_explicit_title:
                 reference += nodes.strong(self.title, self.title)
             else:
-                title = "RFC " + self.title
+                title = 'RFC ' + self.title
                 reference += nodes.strong(title, title)
         except ValueError:
-            msg = self.inliner.reporter.error(__('invalid RFC number %s') % self.target,
-                                              line=self.lineno)
+            msg = self.inliner.reporter.error(
+                __('invalid RFC number %s') % self.target, line=self.lineno
+            )
             prb = self.inliner.problematic(self.rawtext, self.rawtext, msg)
             return [prb], [msg]
 
@@ -241,9 +270,6 @@ class RFC(ReferenceRole):
             return base_url + self.inliner.rfc_url % int(ret[0])
 
 
-_amp_re = re.compile(r'(?<!&)&(?![&\s])')
-
-
 class GUILabel(SphinxRole):
     amp_re = re.compile(r'(?<!&)&(?![&\s])')
 
@@ -270,17 +296,14 @@ class MenuSelection(GUILabel):
         return super().run()
 
 
-_litvar_re = re.compile('{([^}]+)}')
-parens_re = re.compile(r'(\\*{|\\*})')
-
-
 class EmphasizedLiteral(SphinxRole):
     parens_re = re.compile(r'(\\\\|\\{|\\}|{|})')
 
     def run(self) -> tuple[list[Node], list[system_message]]:
         children = self.parse(self.text)
-        node = nodes.literal(self.rawtext, '', *children,
-                             role=self.name.lower(), classes=[self.name])
+        node = nodes.literal(
+            self.rawtext, '', *children, role=self.name.lower(), classes=[self.name]
+        )
 
         return [node], []
 
@@ -292,14 +315,13 @@ class EmphasizedLiteral(SphinxRole):
             if part == '\\\\':  # escaped backslash
                 stack[-1] += '\\'
             elif part == '{':
-                if len(stack) >= 2 and stack[-2] == "{":  # nested
-                    stack[-1] += "{"
+                if len(stack) >= 2 and stack[-2] == '{':  # nested
+                    stack[-1] += '{'
                 else:
                     # start emphasis
-                    stack.append('{')
-                    stack.append('')
+                    stack.extend(('{', ''))
             elif part == '}':
-                if len(stack) == 3 and stack[1] == "{" and len(stack[2]) > 0:
+                if len(stack) == 3 and stack[1] == '{' and len(stack[2]) > 0:
                     # emphasized word found
                     if stack[0]:
                         result.append(nodes.Text(stack[0]))
@@ -324,17 +346,14 @@ class EmphasizedLiteral(SphinxRole):
         return result
 
 
-_abbr_re = re.compile(r'\((.*)\)$', re.S)
-
-
 class Abbreviation(SphinxRole):
-    abbr_re = re.compile(r'\((.*)\)$', re.S)
+    abbr_re = re.compile(r'\((.*)\)$', re.DOTALL)
 
     def run(self) -> tuple[list[Node], list[system_message]]:
         options = self.options.copy()
         matched = self.abbr_re.search(self.text)
         if matched:
-            text = self.text[:matched.start()].strip()
+            text = self.text[: matched.start()].strip()
             options['explanation'] = matched.group(1)
         else:
             text = self.text
@@ -342,6 +361,28 @@ class Abbreviation(SphinxRole):
         return [nodes.abbreviation(self.rawtext, text, **options)], []
 
 
+class Manpage(ReferenceRole):
+    _manpage_re = re.compile(r'^(?P<path>(?P<page>.+)[(.](?P<section>[1-9]\w*)?\)?)$')
+
+    def run(self) -> tuple[list[Node], list[system_message]]:
+        manpage = ws_re.sub(' ', self.target)
+        if m := self._manpage_re.match(manpage):
+            info = m.groupdict()
+        else:
+            info = {'path': manpage, 'page': manpage, 'section': ''}
+
+        inner: nodes.Node
+        text = self.title[1:] if self.disabled else self.title
+        if not self.disabled and self.config.manpages_url:
+            uri = self.config.manpages_url.format(**info)
+            inner = nodes.reference('', text, classes=[self.name], refuri=uri)
+        else:
+            inner = nodes.Text(text)
+        node = addnodes.manpage(self.rawtext, '', inner, classes=[self.name], **info)
+
+        return [node], []
+
+
 # Sphinx provides the `code-block` directive for highlighting code blocks.
 # Docutils provides the `code` role which in theory can be used similarly by
 # defining a custom role for a given programming language:
@@ -366,10 +407,15 @@ class Abbreviation(SphinxRole):
 # way as the Sphinx `code-block` directive.
 #
 # 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 | None = None, content: Sequence[str] = (),
-              ) -> tuple[list[Node], list[system_message]]:
+def code_role(
+    name: str,
+    rawtext: str,
+    text: str,
+    lineno: int,
+    inliner: docutils.parsers.rst.states.Inliner,
+    options: dict[str, Any] | None = None,
+    content: Sequence[str] = (),
+) -> tuple[list[Node], list[system_message]]:
     if options is None:
         options = {}
     options = options.copy()
@@ -400,7 +446,6 @@ specific_docroles: dict[str, RoleFunction] = {
     'download': XRefRole(nodeclass=addnodes.download_reference),
     # links to anything
     'any': AnyXRefRole(warn_dangling=True),
-
     'pep': PEP(),
     'rfc': RFC(),
     'guilabel': GUILabel(),
@@ -408,23 +453,24 @@ specific_docroles: dict[str, RoleFunction] = {
     'file': EmphasizedLiteral(),
     'samp': EmphasizedLiteral(),
     'abbr': Abbreviation(),
+    'manpage': Manpage(),
 }
 
 
-def setup(app: Sphinx) -> dict[str, Any]:
+def setup(app: Sphinx) -> ExtensionMetadata:
     from docutils.parsers.rst import roles
 
     for rolename, nodeclass in generic_docroles.items():
         generic = roles.GenericRole(rolename, nodeclass)
-        role = roles.CustomRole(rolename, generic, {'classes': [rolename]})
-        roles.register_local_role(rolename, role)
+        role = roles.CustomRole(rolename, generic, {'classes': [rolename]})  # type: ignore[arg-type]
+        roles.register_local_role(rolename, role)  # type: ignore[arg-type]
 
     for rolename, func in specific_docroles.items():
-        roles.register_local_role(rolename, func)
+        roles.register_local_role(rolename, func)  # type: ignore[arg-type]
 
     # Since docutils registers it as a canonical role, override it as a
     # canonical role as well.
-    roles.register_canonical_role('code', code_role)
+    roles.register_canonical_role('code', code_role)  # type: ignore[arg-type]
 
     return {
         'version': 'builtin',