def handle_subp_sig(self, sig, signode):
assert USE_LAL, "LAL is not available"
import timeit
start_time = timeit.default_timer()
try:
subp_spec_unit = self.lal_context().get_from_buffer(
"<input>", sig, rule=lal.GrammarRule.subp_spec_rule
)
except Exception:
raise
elapsed = timeit.default_timer() - start_time
print(elapsed)
subp_spec: lal.SubpSpec = subp_spec_unit.root.cast(lal.SubpSpec)
if subp_spec is None:
logger.warning("Couldn't parse the subp spec")
raise ValueError
is_func = subp_spec.f_subp_returns is not None
modname, name, returntype = (
"",
subp_spec.f_subp_name.text,
subp_spec.f_subp_returns.text if is_func else "",
)
kind = "function " if is_func else "procedure "
signode += addnodes.desc_annotation(kind, kind)
fullname = self._resolve_module_name(signode, modname, name)
signode += nodes.Text(" ")
param_list = addnodes.desc_parameterlist()
param_list.child_text_separator = "; "
signode += param_list
if subp_spec.f_subp_params:
for p in subp_spec.f_subp_params.f_params:
param = addnodes.desc_parameter()
param_list += param
for i, name in enumerate(p.f_ids):
param += addnodes.desc_sig_name("", name.text)
if i + 1 < len(p.f_ids):
param += addnodes.desc_sig_punctuation("", ", ")
param += addnodes.desc_sig_punctuation("", " : ")
refnode = self.make_refnode(
p.f_type_expr.text, addnodes.desc_sig_name
)
param += refnode
if returntype:
signode += self.make_refnode(returntype, addnodes.desc_returns)
return fullname
def handle_signature(self, sig: str, signode: desc_signature) -> str:
"""Transform an option description into RST nodes."""
count = 0
firstname = ''
for potential_option in sig.split(', '):
potential_option = potential_option.strip()
m = option_desc_re.match(potential_option)
if not m:
logger.warning(__(
'Malformed option description %r, should '
'look like "opt", "-opt args", "--opt args", '
'"/opt args" or "+opt args"'),
potential_option,
location=signode)
continue
optname, args = m.groups()
if optname[-1] == '[' and args[-1] == ']':
# optional value surrounded by brackets (ex. foo[=bar])
optname = optname[:-1]
args = '[' + args
if count:
if self.env.config.option_emphasise_placeholders:
signode += addnodes.desc_sig_punctuation(',', ',')
signode += addnodes.desc_sig_space()
else:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
if self.env.config.option_emphasise_placeholders:
add_end_bracket = False
if args:
if args[0] == '[' and args[-1] == ']':
add_end_bracket = True
signode += addnodes.desc_sig_punctuation('[', '[')
args = args[1:-1]
elif args[0] == ' ':
signode += addnodes.desc_sig_space()
args = args.strip()
elif args[0] == '=':
signode += addnodes.desc_sig_punctuation('=', '=')
args = args[1:]
for part in samp_role.parse(args):
if isinstance(part, nodes.Text):
signode += nodes.Text(part.astext())
else:
signode += part
if add_end_bracket:
signode += addnodes.desc_sig_punctuation(']', ']')
else:
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
signode['allnames'] = [optname]
else:
signode['allnames'].append(optname)
count += 1
if not firstname:
raise ValueError
return firstname
def add_args_from_options(self, signode: desc_signature) -> None:
params = addnodes.desc_parameterlist()
argnames = self.options.get('argnames', [])
argtypes = self.options.get('argtypes', [])
if len(argtypes):
argnames, argtypes = list_option(argnames), list_option(argtypes)
arglist = ', '.join([
f'{argname}: {argtype}'
for argname, argtype in zip(argnames, argtypes)
])
params = _parse_arglist(arglist, self.env)
signode += params
else:
signode.extend([
addnodes.desc_sig_punctuation('', '('),
addnodes.desc_sig_punctuation('', ')'),
])
def handle_signature(self, sig: str, signode: desc_signature) -> str:
contentnode = addnodes.desc_content()
self.state.nested_parse(self.content, self.content_offset, contentnode)
ty = self.options.get("type")
signode += addnodes.desc_annotation("property ", "property ")
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_sig_punctuation("", ":")
signode += addnodes.desc_sig_keyword_type(ty, ty)
return sig
def _parse_arglist(arglist: str) -> addnodes.desc_parameterlist:
"""Parse a list of arguments using AST parser"""
params = addnodes.desc_parameterlist(arglist)
sig = signature_from_str('(%s)' % arglist)
last_kind = None
for param in sig.parameters.values():
if param.kind != param.POSITIONAL_ONLY and last_kind == param.POSITIONAL_ONLY:
# PEP-570: Separator for Positional Only Parameter: /
params += addnodes.desc_parameter(
'', '', addnodes.desc_sig_operator('', '/'))
if param.kind == param.KEYWORD_ONLY and last_kind in (
param.POSITIONAL_OR_KEYWORD, param.POSITIONAL_ONLY, None):
# PEP-3102: Separator for Keyword Only Parameter: *
params += addnodes.desc_parameter(
'', '', addnodes.desc_sig_operator('', '*'))
node = addnodes.desc_parameter()
if param.kind == param.VAR_POSITIONAL:
node += addnodes.desc_sig_operator('', '*')
node += addnodes.desc_sig_name('', param.name)
elif param.kind == param.VAR_KEYWORD:
node += addnodes.desc_sig_operator('', '**')
node += addnodes.desc_sig_name('', param.name)
else:
node += addnodes.desc_sig_name('', param.name)
if param.annotation is not param.empty:
children = _parse_annotation(param.annotation)
node += addnodes.desc_sig_punctuation('', ':')
node += nodes.Text(' ')
node += addnodes.desc_sig_name('', '', *children) # type: ignore
if param.default is not param.empty:
if param.annotation is not param.empty:
node += nodes.Text(' ')
node += addnodes.desc_sig_operator('', '=')
node += nodes.Text(' ')
else:
node += addnodes.desc_sig_operator('', '=')
node += nodes.inline('',
param.default,
classes=['default_value'],
support_smartquotes=False)
params += node
last_kind = param.kind
if last_kind == Parameter.POSITIONAL_ONLY:
# PEP-570: Separator for Positional Only Parameter: /
params += addnodes.desc_parameter('', '',
addnodes.desc_sig_operator('', '/'))
return params
def process_token(self, token, rules=[]):
type_parts = token.type.split("_")
prev_parts = self._prev_token.type.split("_") if self._prev_token else [""]
if type_parts[0] == "KW":
yield ("node", addnodes.desc_type(text=token.value))
elif type_parts[0] == "SYM":
yield ("node", addnodes.desc_sig_punctuation(text=token.value))
elif type_parts[0] == "ID":
if "id_ext_port" in rules:
yield ("node", addnodes.desc_addname(text=token.value))
else:
yield ("node", addnodes.desc_name(text=token.value))
elif type_parts[0] == "TEXT":
yield ("node", addnodes.desc_sig_element(text=token.value.strip()))
else:
yield ("node", addnodes.desc_sig_element(text=token.value))
def handle_signature(self, sig: str,
signode: addnodes.desc_signature) -> Tuple[str, str]:
"""Transform a signature/object into RST nodes."""
try:
self.obj = BlarkSphinxCache.instance().find_by_name(sig)
except KeyError:
self.obj = MissingDeclaration(sig)
logger.error("Could not find object: %r (signatures unsupported)",
sig)
raise ValueError(f"Code object not found: {sig!r}")
self.env.ref_context["bk:function"] = self.obj
signode["ids"] = [sig]
signode["docname"] = self.env.docname
signode["qualified_name"] = sig
domain_data = self.env.domaindata["bk"][self.signature_prefix.lower()]
domain_data.setdefault(sig, []).append(signode)
sig_prefix = self.get_signature_prefix(sig)
signode += addnodes.desc_annotation(str(sig_prefix), '', *sig_prefix)
signode += addnodes.desc_name(self.obj.name, self.obj.name)
paramlist = addnodes.desc_parameterlist("paramlist")
for block in ("VAR_INPUT", "VAR_IN_OUT", "VAR_OUTPUT", "STRUCT"):
decls = self.obj.declarations_by_block.get(block, {})
for variable, decl in decls.items():
node = addnodes.desc_parameter()
# node += addnodes.desc_sig_operator('', '*')
node += addnodes.desc_type("", decl.type)
node += addnodes.desc_sig_space()
node += addnodes.desc_sig_name("", variable)
if block == "VAR_OUTPUT":
node += addnodes.desc_sig_punctuation(text="=>")
paramlist += node
signode += paramlist
if getattr(self.obj, "return_type", None) is not None:
signode += addnodes.desc_returns()
signode += addnodes.desc_type(text=self.obj.return_type)
prefix = ""
return sig, prefix
def unparse(node: ast.AST) -> List[Node]:
if isinstance(node, ast.Attribute):
return [nodes.Text("%s.%s" % (unparse(node.value)[0], node.attr))]
elif isinstance(node, ast.Expr):
return unparse(node.value)
elif isinstance(node, ast.Index):
return unparse(node.value)
elif isinstance(node, ast.List):
result = [addnodes.desc_sig_punctuation('',
'[')] # type: List[Node]
for elem in node.elts:
result.extend(unparse(elem))
result.append(addnodes.desc_sig_punctuation('', ', '))
result.pop()
result.append(addnodes.desc_sig_punctuation('', ']'))
return result
elif isinstance(node, ast.Module):
return sum((unparse(e) for e in node.body), [])
elif isinstance(node, ast.Name):
return [nodes.Text(node.id)]
elif isinstance(node, ast.Subscript):
result = unparse(node.value)
result.append(addnodes.desc_sig_punctuation('', '['))
result.extend(unparse(node.slice))
result.append(addnodes.desc_sig_punctuation('', ']'))
return result
elif isinstance(node, ast.Tuple):
if node.elts:
result = []
for elem in node.elts:
result.extend(unparse(elem))
result.append(addnodes.desc_sig_punctuation('', ', '))
result.pop()
else:
result = [
addnodes.desc_sig_punctuation('', '('),
addnodes.desc_sig_punctuation('', ')')
]
return result
else:
raise SyntaxError # unsupported syntax
def handle_signature(self, sig, signode):
"""Monkey patch handle signature to add type annotations to parameters.
These type annotations were calculated in autodoc_process_signature.
Bugs in autodoc prevented more direct sensible-seeming approaches.
In particular, if we set signature to any nonzero value for a property, the property name gets doubled.
"""
result = old_handle_signature(self, sig, signode)
if "property" in self.options:
if sig in property_signatures:
retann = property_signatures[sig]
# _parse_annotation puts links and stuff into the type annotation.
# It calls type_to_xref which we monkey patched too.
children = sphinx.domains.python._parse_annotation(
retann, self.env)
signode += addnodes.desc_sig_punctuation(
"", " : ") # "property_name : type"
signode += addnodes.desc_sig_name(retann, "", *children)
return result
def declaration_to_signature(
signode: addnodes.desc_signature,
obj: summary.DeclarationSummary,
*,
env: Optional[sphinx.environment.BuildEnvironment] = None,
):
if env is not None:
signode["ids"] = [obj.qualified_name]
signode["docname"] = env.docname
signode["qualified_name"] = obj.qualified_name
env.domaindata["bk"]["declaration"].setdefault(obj.qualified_name,
[]).append(signode)
yield addnodes.desc_sig_name(obj.name, obj.name)
yield addnodes.desc_sig_punctuation(text=" : ")
yield addnodes.pending_xref(obj.base_type,
nodes.Text(obj.type),
refdomain="bk",
reftype="type",
reftarget=obj.base_type)
def describe_signature(self, signode: TextElement) -> None:
signode.append(addnodes.desc_sig_punctuation('[[', '[['))
signode.append(nodes.Text(self.arg))
signode.append(addnodes.desc_sig_punctuation(']]', ']]'))
def handle_signature(self, sig: str, signode: desc_signature) -> Tuple[str, str]:
"""Breaks down construct signatures
Parses out prefix and argument list from construct definition. The
namespace and class will be determined by the nesting of domain
directives.
"""
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
member, arglist = sig.split('(', 1)
member = member.strip()
arglist = arglist[:-1].strip()
else:
member = sig
arglist = None
# If construct is nested, prefix the current prefix
prefix = self.env.ref_context.get('js:object', None)
mod_name = self.env.ref_context.get('js:module')
name = member
try:
member_prefix, member_name = member.rsplit('.', 1)
except ValueError:
member_name = name
member_prefix = ''
finally:
name = member_name
if prefix and member_prefix:
prefix = '.'.join([prefix, member_prefix])
elif prefix is None and member_prefix:
prefix = member_prefix
fullname = name
if prefix:
fullname = '.'.join([prefix, name])
signode['module'] = mod_name
signode['object'] = prefix
signode['fullname'] = fullname
display_prefix = self.get_display_prefix()
if display_prefix:
signode += addnodes.desc_annotation('', '', *display_prefix)
actual_prefix = None
if prefix:
actual_prefix = prefix
elif mod_name:
actual_prefix = mod_name
if actual_prefix:
addName = addnodes.desc_addname('', '')
for p in actual_prefix.split('.'):
addName += addnodes.desc_sig_name(p, p)
addName += addnodes.desc_sig_punctuation('.', '.')
signode += addName
signode += addnodes.desc_name('', '', addnodes.desc_sig_name(name, name))
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, prefix
