Sphinx 8.0.2__py3-none-any.whl → 8.1.1__py3-none-any.whl

sphinx/ext/intersphinx/_load.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import concurrent.futures
-import functools
 import posixpath
 import time
 from operator import itemgetter
@@ -20,7 +19,8 @@ from sphinx.util.inventory import InventoryFile
 
 if TYPE_CHECKING:
     from pathlib import Path
-    from typing import IO
+
+    from urllib3.response import HTTPResponse
 
     from sphinx.application import Sphinx
     from sphinx.config import Config
@@ -31,7 +31,7 @@ if TYPE_CHECKING:
         InventoryName,
         InventoryURI,
     )
-    from sphinx.util.typing import Inventory
+    from sphinx.util.typing import Inventory, _ReadableStream
 
 
 def validate_intersphinx_mapping(app: Sphinx, config: Config) -> None:
@@ -89,8 +89,10 @@ def validate_intersphinx_mapping(app: Sphinx, config: Config) -> None:
         # ensure target URIs are non-empty and unique
         if not uri or not isinstance(uri, str):
             errors += 1
-            msg = __('Invalid target URI value `%r` in intersphinx_mapping[%r][0]. '
-                     'Target URIs must be unique non-empty strings.')
+            msg = __(
+                'Invalid target URI value `%r` in intersphinx_mapping[%r][0]. '
+                'Target URIs must be unique non-empty strings.'
+            )
             LOGGER.error(msg, uri, name)
             del config.intersphinx_mapping[name]
             continue
@@ -105,9 +107,12 @@ def validate_intersphinx_mapping(app: Sphinx, config: Config) -> None:
             continue
         seen[uri] = name
 
+        if not isinstance(inv, tuple | list):
+            inv = (inv,)
+
         # ensure inventory locations are None or non-empty
         targets: list[InventoryLocation] = []
-        for target in (inv if isinstance(inv, (tuple | list)) else (inv,)):
+        for target in inv:
             if target is None or target and isinstance(target, str):
                 targets.append(target)
             else:
@@ -143,9 +148,13 @@ def load_mappings(app: Sphinx) -> None:
     projects = []
     for name, (uri, locations) in intersphinx_mapping.values():
         try:
-            project = _IntersphinxProject(name=name, target_uri=uri, locations=locations)
+            project = _IntersphinxProject(
+                name=name, target_uri=uri, locations=locations
+            )
         except ValueError as err:
-            msg = __('An invalid intersphinx_mapping entry was added after normalisation.')
+            msg = __(
+                'An invalid intersphinx_mapping entry was added after normalisation.'
+            )
             raise ConfigError(msg) from err
         else:
             projects.append(project)
@@ -201,14 +210,24 @@ def _fetch_inventory_group(
     config: Config,
     srcdir: Path,
 ) -> bool:
-    cache_time = now - config.intersphinx_cache_limit * 86400
+    if config.intersphinx_cache_limit >= 0:
+        # Positive value: cache is expired if its timestamp is below
+        # `now - X days`.
+        cache_time = now - config.intersphinx_cache_limit * 86400
+    else:
+        # Negative value: cache is expired if its timestamp is below
+        # zero, which is impossible.
+        cache_time = 0
 
     updated = False
     failures = []
 
     for location in project.locations:
         # location is either None or a non-empty string
-        inv = f'{project.target_uri}/{INVENTORY_FILENAME}' if location is None else location
+        if location is None:
+            inv = posixpath.join(project.target_uri, INVENTORY_FILENAME)
+        else:
+            inv = location
 
         # decide whether the inventory must be read: always read local
         # files; remote ones only if the cache time is expired
@@ -217,8 +236,11 @@ def _fetch_inventory_group(
             or project.target_uri not in cache
             or cache[project.target_uri][1] < cache_time
         ):
-            LOGGER.info(__("loading intersphinx inventory '%s' from %s ..."),
-                        project.name, _get_safe_url(inv))
+            LOGGER.info(
+                __("loading intersphinx inventory '%s' from %s ..."),
+                project.name,
+                _get_safe_url(inv),
+            )
 
             try:
                 invdata = _fetch_inventory(
@@ -239,14 +261,21 @@ def _fetch_inventory_group(
     if not failures:
         pass
     elif len(failures) < len(project.locations):
-        LOGGER.info(__('encountered some issues with some of the inventories,'
-                       ' but they had working alternatives:'))
+        LOGGER.info(
+            __(
+                'encountered some issues with some of the inventories,'
+                ' but they had working alternatives:'
+            )
+        )
         for fail in failures:
             LOGGER.info(*fail)
     else:
         issues = '\n'.join(f[0] % f[1:] for f in failures)
-        LOGGER.warning(__('failed to reach any of the inventories '
-                          'with the following issues:') + '\n' + issues)
+        LOGGER.warning(
+            __('failed to reach any of the inventories ' 'with the following issues:')
+            + '\n'
+            + issues
+        )
     return updated
 
 
@@ -261,7 +290,7 @@ def fetch_inventory(app: Sphinx, uri: InventoryURI, inv: str) -> Inventory:
 
 
 def _fetch_inventory(
-    *, target_uri: InventoryURI, inv_location: str, config: Config, srcdir: Path,
+    *, target_uri: InventoryURI, inv_location: str, config: Config, srcdir: Path
 ) -> Inventory:
     """Fetch, parse and return an intersphinx inventory file."""
     # both *target_uri* (base URI of the links to generate)
@@ -272,12 +301,16 @@ def _fetch_inventory(
         target_uri = _strip_basic_auth(target_uri)
     try:
         if '://' in inv_location:
-            f = _read_from_url(inv_location, config=config)
+            f: _ReadableStream[bytes] = _read_from_url(inv_location, config=config)
         else:
             f = open(path.join(srcdir, inv_location), 'rb')  # NoQA: SIM115
     except Exception as err:
-        err.args = ('intersphinx inventory %r not fetchable due to %s: %s',
-                    inv_location, err.__class__, str(err))
+        err.args = (
+            'intersphinx inventory %r not fetchable due to %s: %s',
+            inv_location,
+            err.__class__,
+            str(err),
+        )
         raise
     try:
         if hasattr(f, 'url'):
@@ -289,17 +322,22 @@ def _fetch_inventory(
                 if target_uri in {
                     inv_location,
                     path.dirname(inv_location),
-                    path.dirname(inv_location) + '/'
+                    path.dirname(inv_location) + '/',
                 }:
                     target_uri = path.dirname(new_inv_location)
         with f:
             try:
                 invdata = InventoryFile.load(f, target_uri, posixpath.join)
             except ValueError as exc:
-                raise ValueError('unknown or unsupported inventory version: %r' % exc) from exc
+                msg = f'unknown or unsupported inventory version: {exc!r}'
+                raise ValueError(msg) from exc
     except Exception as err:
-        err.args = ('intersphinx inventory %r not readable due to %s: %s',
-                    inv_location, err.__class__.__name__, str(err))
+        err.args = (
+            'intersphinx inventory %r not readable due to %s: %s',
+            inv_location,
+            err.__class__.__name__,
+            str(err),
+        )
         raise
     else:
         return invdata
@@ -351,7 +389,7 @@ def _strip_basic_auth(url: str) -> str:
     return urlunsplit(frags)
 
 
-def _read_from_url(url: str, *, config: Config) -> IO:
+def _read_from_url(url: str, *, config: Config) -> HTTPResponse:
     """Reads data from *url* with an HTTP *GET*.
 
     This function supports fetching from resources which use basic HTTP auth as
@@ -367,12 +405,19 @@ def _read_from_url(url: str, *, config: Config) -> IO:
     :return: data read from resource described by *url*
     :rtype: ``file``-like object
     """
-    r = requests.get(url, stream=True, timeout=config.intersphinx_timeout,
-                     _user_agent=config.user_agent,
-                     _tls_info=(config.tls_verify, config.tls_cacerts))
+    r = requests.get(
+        url,
+        stream=True,
+        timeout=config.intersphinx_timeout,
+        _user_agent=config.user_agent,
+        _tls_info=(config.tls_verify, config.tls_cacerts),
+    )
     r.raise_for_status()
-    r.raw.url = r.url
-    # decode content-body based on the header.
-    # ref: https://github.com/psf/requests/issues/2155
-    r.raw.read = functools.partial(r.raw.read, decode_content=True)
+
+    # For inv_location / new_inv_location
+    r.raw.url = r.url  # type: ignore[union-attr]
+
+    # Decode content-body based on the header.
+    # xref: https://github.com/psf/requests/issues/2155
+    r.raw.decode_content = True
     return r.raw

sphinx/ext/intersphinx/_resolve.py

@@ -32,9 +32,13 @@ if TYPE_CHECKING:
     from sphinx.util.typing import Inventory, InventoryItem, RoleFunction
 
 
-def _create_element_from_result(domain: Domain, inv_name: InventoryName | None,
-                                data: InventoryItem,
-                                node: pending_xref, contnode: TextElement) -> nodes.reference:
+def _create_element_from_result(
+    domain: Domain,
+    inv_name: InventoryName | None,
+    data: InventoryItem,
+    node: pending_xref,
+    contnode: TextElement,
+) -> nodes.reference:
     proj, version, uri, dispname = data
     if '://' not in uri and node.get('refdoc'):
         # get correct path in case of subdirectories
@@ -51,8 +55,11 @@ def _create_element_from_result(domain: Domain, inv_name: InventoryName | None,
         # use whatever title was given, but strip prefix
         title = contnode.astext()
         if inv_name is not None and title.startswith(inv_name + ':'):
-            newnode.append(contnode.__class__(title[len(inv_name) + 1:],
-                                              title[len(inv_name) + 1:]))
+            newnode.append(
+                contnode.__class__(
+                    title[len(inv_name) + 1 :], title[len(inv_name) + 1 :]
+                )
+            )
         else:
             newnode.append(contnode)
     else:
@@ -62,10 +69,14 @@ def _create_element_from_result(domain: Domain, inv_name: InventoryName | None,
 
 
 def _resolve_reference_in_domain_by_target(
-        inv_name: InventoryName | None, inventory: Inventory,
-        domain: Domain, objtypes: Iterable[str],
-        target: str,
-        node: pending_xref, contnode: TextElement) -> nodes.reference | None:
+    inv_name: InventoryName | None,
+    inventory: Inventory,
+    domain: Domain,
+    objtypes: Iterable[str],
+    target: str,
+    node: pending_xref,
+    contnode: TextElement,
+) -> nodes.reference | None:
     for objtype in objtypes:
         if objtype not in inventory:
             # Continue if there's nothing of this kind in the inventory
@@ -79,13 +90,34 @@ def _resolve_reference_in_domain_by_target(
             # * 'term': https://github.com/sphinx-doc/sphinx/issues/9291
             # * 'label': https://github.com/sphinx-doc/sphinx/issues/12008
             target_lower = target.lower()
-            insensitive_matches = list(filter(lambda k: k.lower() == target_lower,
-                                              inventory[objtype].keys()))
+            insensitive_matches = list(
+                filter(lambda k: k.lower() == target_lower, inventory[objtype].keys())
+            )
             if len(insensitive_matches) > 1:
+                data_items = {
+                    inventory[objtype][match] for match in insensitive_matches
+                }
                 inv_descriptor = inv_name or 'main_inventory'
-                LOGGER.warning(__("inventory '%s': multiple matches found for %s:%s"),
-                               inv_descriptor, objtype, target,
-                               type='intersphinx',  subtype='external', location=node)
+                if len(data_items) == 1:  # these are duplicates; relatively innocuous
+                    LOGGER.debug(
+                        __("inventory '%s': duplicate matches found for %s:%s"),
+                        inv_descriptor,
+                        objtype,
+                        target,
+                        type='intersphinx',
+                        subtype='external',
+                        location=node,
+                    )
+                else:
+                    LOGGER.warning(
+                        __("inventory '%s': multiple matches found for %s:%s"),
+                        inv_descriptor,
+                        objtype,
+                        target,
+                        type='intersphinx',
+                        subtype='external',
+                        location=node,
+                    )
             if insensitive_matches:
                 data = inventory[objtype][insensitive_matches[0]]
             else:
@@ -100,12 +132,16 @@ def _resolve_reference_in_domain_by_target(
     return None
 
 
-def _resolve_reference_in_domain(env: BuildEnvironment,
-                                 inv_name: InventoryName | None, inventory: Inventory,
-                                 honor_disabled_refs: bool,
-                                 domain: Domain, objtypes: Iterable[str],
-                                 node: pending_xref, contnode: TextElement,
-                                 ) -> nodes.reference | None:
+def _resolve_reference_in_domain(
+    env: BuildEnvironment,
+    inv_name: InventoryName | None,
+    inventory: Inventory,
+    honor_disabled_refs: bool,
+    domain: Domain,
+    objtypes: Iterable[str],
+    node: pending_xref,
+    contnode: TextElement,
+) -> nodes.reference | None:
     obj_types: dict[str, None] = {}.fromkeys(objtypes)
 
     # we adjust the object types for backwards compatibility
@@ -123,15 +159,16 @@ def _resolve_reference_in_domain(env: BuildEnvironment,
     # now that the objtypes list is complete we can remove the disabled ones
     if honor_disabled_refs:
         disabled = set(env.config.intersphinx_disabled_reftypes)
-        obj_types = {obj_type: None
-                     for obj_type in obj_types
-                     if obj_type not in disabled}
+        obj_types = {
+            obj_type: None for obj_type in obj_types if obj_type not in disabled
+        }
 
     objtypes = [*obj_types.keys()]
 
     # without qualification
-    res = _resolve_reference_in_domain_by_target(inv_name, inventory, domain, objtypes,
-                                                 node['reftarget'], node, contnode)
+    res = _resolve_reference_in_domain_by_target(
+        inv_name, inventory, domain, objtypes, node['reftarget'], node, contnode
+    )
     if res is not None:
         return res
 
@@ -139,14 +176,19 @@ def _resolve_reference_in_domain(env: BuildEnvironment,
     full_qualified_name = domain.get_full_qualified_name(node)
     if full_qualified_name is None:
         return None
-    return _resolve_reference_in_domain_by_target(inv_name, inventory, domain, objtypes,
-                                                  full_qualified_name, node, contnode)
-
-
-def _resolve_reference(env: BuildEnvironment,
-                       inv_name: InventoryName | None, inventory: Inventory,
-                       honor_disabled_refs: bool,
-                       node: pending_xref, contnode: TextElement) -> nodes.reference | None:
+    return _resolve_reference_in_domain_by_target(
+        inv_name, inventory, domain, objtypes, full_qualified_name, node, contnode
+    )
+
+
+def _resolve_reference(
+    env: BuildEnvironment,
+    inv_name: InventoryName | None,
+    inventory: Inventory,
+    honor_disabled_refs: bool,
+    node: pending_xref,
+    contnode: TextElement,
+) -> nodes.reference | None:
     # disabling should only be done if no inventory is given
     honor_disabled_refs = honor_disabled_refs and inv_name is None
     intersphinx_disabled_reftypes = env.config.intersphinx_disabled_reftypes
@@ -156,14 +198,23 @@ def _resolve_reference(env: BuildEnvironment,
 
     typ = node['reftype']
     if typ == 'any':
-        for domain_name, domain in env.domains.items():
-            if honor_disabled_refs and f'{domain_name}:*' in intersphinx_disabled_reftypes:
+        for domain in env.domains.sorted():
+            if (
+                honor_disabled_refs
+                and f'{domain.name}:*' in intersphinx_disabled_reftypes
+            ):
                 continue
             objtypes: Iterable[str] = domain.object_types.keys()
-            res = _resolve_reference_in_domain(env, inv_name, inventory,
-                                               honor_disabled_refs,
-                                               domain, objtypes,
-                                               node, contnode)
+            res = _resolve_reference_in_domain(
+                env,
+                inv_name,
+                inventory,
+                honor_disabled_refs,
+                domain,
+                objtypes,
+                node,
+                contnode,
+            )
             if res is not None:
                 return res
         return None
@@ -178,20 +229,28 @@ def _resolve_reference(env: BuildEnvironment,
         objtypes = domain.objtypes_for_role(typ) or ()
         if not objtypes:
             return None
-        return _resolve_reference_in_domain(env, inv_name, inventory,
-                                            honor_disabled_refs,
-                                            domain, objtypes,
-                                            node, contnode)
+        return _resolve_reference_in_domain(
+            env,
+            inv_name,
+            inventory,
+            honor_disabled_refs,
+            domain,
+            objtypes,
+            node,
+            contnode,
+        )
 
 
 def inventory_exists(env: BuildEnvironment, inv_name: InventoryName) -> bool:
     return inv_name in InventoryAdapter(env).named_inventory
 
 
-def resolve_reference_in_inventory(env: BuildEnvironment,
-                                   inv_name: InventoryName,
-                                   node: pending_xref, contnode: TextElement,
-                                   ) -> nodes.reference | None:
+def resolve_reference_in_inventory(
+    env: BuildEnvironment,
+    inv_name: InventoryName,
+    node: pending_xref,
+    contnode: TextElement,
+) -> nodes.reference | None:
     """Attempt to resolve a missing reference via intersphinx references.
 
     Resolution is tried in the given inventory with the target as is.
@@ -199,26 +258,39 @@ def resolve_reference_in_inventory(env: BuildEnvironment,
     Requires ``inventory_exists(env, inv_name)``.
     """
     assert inventory_exists(env, inv_name)
-    return _resolve_reference(env, inv_name, InventoryAdapter(env).named_inventory[inv_name],
-                              False, node, contnode)
-
-
-def resolve_reference_any_inventory(env: BuildEnvironment,
-                                    honor_disabled_refs: bool,
-                                    node: pending_xref, contnode: TextElement,
-                                    ) -> nodes.reference | None:
+    return _resolve_reference(
+        env,
+        inv_name,
+        InventoryAdapter(env).named_inventory[inv_name],
+        False,
+        node,
+        contnode,
+    )
+
+
+def resolve_reference_any_inventory(
+    env: BuildEnvironment,
+    honor_disabled_refs: bool,
+    node: pending_xref,
+    contnode: TextElement,
+) -> nodes.reference | None:
     """Attempt to resolve a missing reference via intersphinx references.
 
     Resolution is tried with the target as is in any inventory.
     """
-    return _resolve_reference(env, None, InventoryAdapter(env).main_inventory,
-                              honor_disabled_refs,
-                              node, contnode)
-
-
-def resolve_reference_detect_inventory(env: BuildEnvironment,
-                                       node: pending_xref, contnode: TextElement,
-                                       ) -> nodes.reference | None:
+    return _resolve_reference(
+        env,
+        None,
+        InventoryAdapter(env).main_inventory,
+        honor_disabled_refs,
+        node,
+        contnode,
+    )
+
+
+def resolve_reference_detect_inventory(
+    env: BuildEnvironment, node: pending_xref, contnode: TextElement
+) -> nodes.reference | None:
     """Attempt to resolve a missing reference via intersphinx references.
 
     Resolution is tried first with the target as is in any inventory.
@@ -244,8 +316,9 @@ def resolve_reference_detect_inventory(env: BuildEnvironment,
     return res_inv
 
 
-def missing_reference(app: Sphinx, env: BuildEnvironment, node: pending_xref,
-                      contnode: TextElement) -> nodes.reference | None:
+def missing_reference(
+    app: Sphinx, env: BuildEnvironment, node: pending_xref, contnode: TextElement
+) -> nodes.reference | None:
     """Attempt to resolve a missing reference via intersphinx references."""
     return resolve_reference_detect_inventory(env, node, contnode)
 
@@ -257,7 +330,11 @@ class IntersphinxDispatcher(CustomReSTDispatcher):
     """
 
     def role(
-        self, role_name: str, language_module: ModuleType, lineno: int, reporter: Reporter,
+        self,
+        role_name: str,
+        language_module: ModuleType,
+        lineno: int,
+        reporter: Reporter,
     ) -> tuple[RoleFunction, list[system_message]]:
         if len(role_name) > 9 and role_name.startswith(('external:', 'external+')):
             return IntersphinxRole(role_name), []
@@ -296,16 +373,17 @@ class IntersphinxRole(SphinxRole):
 
         if domain_name is not None:
             # the user specified a domain, so we only check that
-            if (domain := self.env.domains.get(domain_name)) is None:
+            if domain_name not in self.env.domains:
                 self._emit_warning(
                     __('domain for external cross-reference not found: %r'), domain_name
                 )
                 return [], []
-            if (role_func := domain.roles.get(role_name)) is None:
+            domain = self.env.domains[domain_name]
+            role_func = domain.roles.get(role_name)
+            if role_func is None:
                 msg = 'role for external cross-reference not found in domain %r: %r'
-                if (
-                    object_types := domain.object_types.get(role_name)
-                ) is not None and object_types.roles:
+                object_types = domain.object_types.get(role_name)
+                if object_types is not None and object_types.roles:
                     self._emit_warning(
                         __(f'{msg} (perhaps you meant one of: %s)'),
                         domain_name,
@@ -323,7 +401,7 @@ class IntersphinxRole(SphinxRole):
             if default_domain := self.env.temp_data.get('default_domain'):
                 domains.append(default_domain)
             if (
-                std_domain := self.env.domains.get('std')
+                std_domain := self.env.domains.standard_domain
             ) is not None and std_domain not in domains:
                 domains.append(std_domain)
 
@@ -454,7 +532,9 @@ class IntersphinxRole(SphinxRole):
         except ExtensionError:
             return False
 
-    def invoke_role(self, role: tuple[str, str]) -> tuple[list[Node], list[system_message]]:
+    def invoke_role(
+        self, role: tuple[str, str]
+    ) -> tuple[list[Node], list[system_message]]:
         """Invoke the role described by a ``(domain, role name)`` pair."""
         _deprecation_warning(
             __name__, f'{self.__class__.__name__}.invoke_role', '', remove=(9, 0)
@@ -464,8 +544,15 @@ class IntersphinxRole(SphinxRole):
             role_func = domain.role(role[1])
             assert role_func is not None
 
-            return role_func(':'.join(role), self.rawtext, self.text, self.lineno,
-                             self.inliner, self.options, self.content)
+            return role_func(
+                ':'.join(role),
+                self.rawtext,
+                self.text,
+                self.lineno,
+                self.inliner,
+                self.options,
+                self.content,
+            )
         else:
             return [], []
 
@@ -486,13 +573,20 @@ class IntersphinxRoleResolver(ReferencesResolver):
             inv_name = node['inventory']
             if inv_name is not None:
                 assert inventory_exists(self.env, inv_name)
-                newnode = resolve_reference_in_inventory(self.env, inv_name, node, contnode)
+                newnode = resolve_reference_in_inventory(
+                    self.env, inv_name, node, contnode
+                )
             else:
-                newnode = resolve_reference_any_inventory(self.env, False, node, contnode)
+                newnode = resolve_reference_any_inventory(
+                    self.env, False, node, contnode
+                )
             if newnode is None:
                 typ = node['reftype']
-                msg = (__('external %s:%s reference target not found: %s') %
-                       (node['refdomain'], typ, node['reftarget']))
+                msg = __('external %s:%s reference target not found: %s') % (
+                    node['refdomain'],
+                    typ,
+                    node['reftarget'],
+                )
                 LOGGER.warning(msg, location=node, type='ref', subtype=typ)
                 node.replace_self(contnode)
             else:

sphinx/ext/intersphinx/_shared.py

@@ -54,7 +54,7 @@ class _IntersphinxProject:
         'locations':  'A tuple of local or remote targets containing '
                       'the inventory data to fetch. '
                       'None indicates the default inventory file name.',
-    }
+    }  # fmt: skip
 
     def __init__(
         self,
@@ -83,10 +83,12 @@ class _IntersphinxProject:
         object.__setattr__(self, 'locations', tuple(locations))
 
     def __repr__(self) -> str:
-        return (f'{self.__class__.__name__}('
-                f'name={self.name!r}, '
-                f'target_uri={self.target_uri!r}, '
-                f'locations={self.locations!r})')
+        return (
+            f'{self.__class__.__name__}('
+            f'name={self.name!r}, '
+            f'target_uri={self.target_uri!r}, '
+            f'locations={self.locations!r})'
+        )
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, _IntersphinxProject):

sphinx/ext/linkcode.py

@@ -31,6 +31,12 @@ def doctree_read(app: Sphinx, doctree: Node) -> None:
         raise LinkcodeError(msg)
     assert resolve_target is not None  # for mypy
 
+    # By default, the linkcode extension will only inject references
+    # for an ``html`` builder. If a builder wishes to support managing
+    # references generated by linkcode as well, it can define the
+    # ``supported_linkcode`` attribute.
+    node_only_expr = getattr(app.builder, 'supported_linkcode', 'html')
+
     domain_keys = {
         'py': ['module', 'fullname'],
         'c': ['names'],
@@ -67,7 +73,7 @@ def doctree_read(app: Sphinx, doctree: Node) -> None:
             uris.add(uri)
 
             inline = nodes.inline('', _('[source]'), classes=['viewcode-link'])
-            onlynode = addnodes.only(expr='html')
+            onlynode = addnodes.only(expr=node_only_expr)
             onlynode += nodes.reference('', '', inline, internal=False, refuri=uri)
             signode += onlynode