def missing_reference(app, env, node, contnode):
target = node['reftarget']
typ = node['reftype']
domain = node.get('refdomain')
if domain in exacts and target in exacts[domain]:
raise NoUri()
if (domain, typ) in exactsType and target in exactsType[(domain, typ)]:
raise NoUri()
if domain in prefixes and any(
target.startswith(a) for a in prefixes[domain]):
raise NoUri()
if not domain and typ == "any" and target in anys:
raise NoUri()
def run(self, **kwargs: Any) -> None:
for node in self.document.traverse(addnodes.pending_xref):
contnode = cast(nodes.TextElement, node[0].deepcopy())
newnode = None
typ = node['reftype']
target = node['reftarget']
refdoc = node.get('refdoc', self.env.docname)
domain = None
try:
if 'refdomain' in node and node['refdomain']:
# let the domain try to resolve the reference
try:
domain = self.env.domains[node['refdomain']]
except KeyError as exc:
raise NoUri(target, typ) from exc
newnode = domain.resolve_xref(self.env, refdoc, self.app.builder,
typ, target, node, contnode)
# really hardwired reference types
elif typ == 'any':
newnode = self.resolve_anyref(refdoc, node, contnode)
# no new node found? try the missing-reference event
if newnode is None:
newnode = self.app.emit_firstresult('missing-reference', self.env,
node, contnode,
allowed_exceptions=(NoUri,))
# still not found? warn if node wishes to be warned about or
# we are in nit-picky mode
if newnode is None:
self.warn_missing_reference(refdoc, typ, target, node, domain)
except NoUri:
newnode = contnode
node.replace_self(newnode or contnode)
def run(self, **kwargs: Any) -> None:
for node in self.document.traverse(addnodes.pending_xref):
content = self.find_pending_xref_condition(node, ("resolved", "*"))
if content:
contnode = cast(Element, content[0].deepcopy())
else:
contnode = cast(Element, node[0].deepcopy())
newnode = None
typ = node['reftype']
target = node['reftarget']
refdoc = node.get('refdoc', self.env.docname)
domain = None
try:
if 'refdomain' in node and node['refdomain']:
# let the domain try to resolve the reference
try:
domain = self.env.domains[node['refdomain']]
except KeyError as exc:
raise NoUri(target, typ) from exc
newnode = domain.resolve_xref(self.env, refdoc,
self.app.builder, typ,
target, node, contnode)
# really hardwired reference types
elif typ == 'any':
newnode = self.resolve_anyref(refdoc, node, contnode)
# no new node found? try the missing-reference event
if newnode is None:
newnode = self.app.emit_firstresult(
'missing-reference',
self.env,
node,
contnode,
allowed_exceptions=(NoUri, ))
# still not found? warn if node wishes to be warned about or
# we are in nit-picky mode
if newnode is None:
self.warn_missing_reference(refdoc, typ, target, node,
domain)
except NoUri:
newnode = None
if newnode:
newnodes: List[Node] = [newnode]
else:
newnodes = [contnode]
if newnode is None and isinstance(
node[0], addnodes.pending_xref_condition):
matched = self.find_pending_xref_condition(node, ("*", ))
if matched:
newnodes = matched
else:
logger.warning(__(
'Could not determine the fallback text for the '
'cross-reference. Might be a bug.'),
location=node)
node.replace_self(newnodes)
def missing_reference(
app: Sphinx, env: BuildEnvironment, node: pending_xref, contnode: Element
) -> Element:
"""
Remove or resolve references to third party packages.
- The ``kubernetes_asyncio`` package doesn't provide any reference
documentsion for its API. To allow nitpicking on missing references we
take the approach to exclude all ``kubernetes_asyncio`` references.
- The ``aiopg`` package uses top-level imports (e.g. ``from aiopg import
Connection``) and writes the documentation as such. But the actual
classes and functions are defined in e.g. ``aiopg.conection`` or
``aiopg.cursor``. We rewrite the references accordingly.
"""
reftarget = node.get("reftarget", "")
if node.get("refdomain") == "py":
if reftarget.startswith("kubernetes_asyncio."):
raise NoUri()
elif reftarget.startswith("aiohttp.client_reqrep."):
node.attributes["reftarget"] = "aiohttp." + reftarget[22:]
elif reftarget.startswith("aiopg.connection."):
node.attributes["reftarget"] = "aiopg." + reftarget[17:]
elif reftarget.startswith("aiopg.cursor."):
node.attributes["reftarget"] = "aiopg." + reftarget[13:]
def get_target_uri(self, docname, typ=None):
if docname not in self._docnames:
# TODO: check whether docname is included in another target
# document and somehow link to it
raise NoUri(docname, typ)
else:
return '%' + docname
def get_target_uri(self, docname: str, typ: str = None) -> str:
if docname not in self.docnames:
raise NoUri(docname, typ)
else:
return '%' + docname
def get_target_uri(self, docname: str, typ: str = None) -> str:
if typ == 'token':
return ''
raise NoUri(docname, typ)