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