def complete(self, text, word): # We never want to fallback on readline. # Even more so when argcomplete does this by calling bash -c compgen. check_output = argcomplete.subprocess.check_output argcomplete.subprocess.check_output = lambda *a, **k: b"" (cword_prequote, cword_prefix, cword_suffix, comp_words, first_colon_pos) = argcomplete.split_line(text) comp_words.insert(0, sys.argv[0]) try: completions = self.completer._get_completions(comp_words, cword_prefix, cword_prequote, first_colon_pos) except GdbCompleterRequired as e: return e.gdbcompleter except BaseException as e: # This is not expected, but gdb doesn't give us a # backtrace in this case, we print it ourself. print("\nAn exception occured during auto-completion code.") print("%s> %s %s" % (traceback.format_exc(), self.cmdname, text), end="") return [] finally: # Don't forget we cheated, fix this and hope no one saw us. argcomplete.subprocess.check_output = check_output # The characters used by gdb to decide what a 'word' is aren't # controled by us. We need to workaround this by ommiting the # first part of the actual word... # The downside of this trick is we won't see the whole word # in gdb's listing, only what he considers the word... return [c[len(cword_prefix) - len(word) :].strip() for c in completions]
def run_completer(self, parser, completer, command, point=None, **kwargs): cword_prequote, cword_prefix, cword_suffix, comp_words, first_colon_pos = split_line(command) completions = completer._get_completions( comp_words, cword_prefix, cword_prequote, first_colon_pos) return completions
def complete(self, text, word): # We never want to fallback on readline. # Even more so when argcomplete does this by calling bash -c compgen. check_output = argcomplete.subprocess.check_output argcomplete.subprocess.check_output = lambda *a, **k: b"" (cword_prequote, cword_prefix, cword_suffix, comp_words, first_colon_pos) = argcomplete.split_line(text) comp_words.insert(0, sys.argv[0]) try: completions = self.completer._get_completions( comp_words, cword_prefix, cword_prequote, first_colon_pos) except GdbCompleterRequired as e: return e.gdbcompleter except BaseException as e: # This is not expected, but gdb doesn't give us a # backtrace in this case, we print it ourself. print("\nAn exception occured during auto-completion code.") print("%s> %s %s" % (traceback.format_exc(), self.cmdname, text), end="") return [] finally: # Don't forget we cheated, fix this and hope no one saw us. argcomplete.subprocess.check_output = check_output # The characters used by gdb to decide what a 'word' is aren't # controled by us. We need to workaround this by ommiting the # first part of the actual word... # The downside of this trick is we won't see the whole word # in gdb's listing, only what he considers the word... return [c[len(cword_prefix) - len(word):].strip() for c in completions]
def do_command_completion(): """ ndt command completion function """ output_stream = os.fdopen(8, "wb") ifs = os.environ.get("_ARGCOMPLETE_IFS", "\v") if len(ifs) != 1: sys.exit(1) current = os.environ["COMP_CUR"] prev = os.environ["COMP_PREV"] comp_line = os.environ["COMP_LINE"] comp_point = int(os.environ["COMP_POINT"]) # Adjust comp_point for wide chars if USING_PYTHON2: comp_point = len(comp_line[:comp_point].decode(SYS_ENCODING)) else: comp_point = len( comp_line.encode(SYS_ENCODING)[:comp_point].decode(SYS_ENCODING)) comp_line = ensure_str(comp_line) comp_words = split_line(comp_line, comp_point)[3] if "COMP_CWORD" in os.environ and os.environ["COMP_CWORD"] == "1": keys = [ x for x in list(COMMAND_MAPPINGS.keys()) if x.startswith(current) ] output_stream.write(ifs.join(keys).encode(SYS_ENCODING)) output_stream.flush() sys.exit(0) else: command = prev if len(comp_words) > 1: command = comp_words[1] if command not in COMMAND_MAPPINGS: sys.exit(1) command_type = COMMAND_MAPPINGS[command] if command_type == "shell": command = command + ".sh" if command_type == "ndtshell": command = command + ".sh" if command_type == "ndtshell" or command_type == "ndtscript": command = find_include(command) if command_type == "shell" or command_type == "script" or \ command_type == "ndtshell" or command_type == "ndtscript": proc = Popen([command], stderr=PIPE, stdout=PIPE) output = proc.communicate()[0] if proc.returncode == 0: output_stream.write( output.replace("\n", ifs).decode(SYS_ENCODING)) output_stream.flush() else: sys.exit(1) else: line = comp_line[3:].lstrip() os.environ['COMP_POINT'] = str(comp_point - (len(comp_line) - len(line))) os.environ['COMP_LINE'] = line parts = command_type.split(":") getattr(__import__(parts[0], fromlist=[parts[1]]), parts[1])() sys.exit(0)
def get_argcomplete_prefix(): if "_ARGCOMPLETE_BENCHMARK" in os.environ: os.environ["_ARGCOMPLETE_IFS"] = "\n" # os.environ["COMP_LINE"] = "cheribuild.py " # return all targets os.environ["COMP_LINE"] = "cheribuild.py foo --sq" # return all options starting with --sq # os.environ["COMP_LINE"] = "cheribuild.py foo --no-s" # return all options os.environ["COMP_POINT"] = str(len(os.environ["COMP_LINE"])) comp_line = argcomplete.ensure_str(os.environ["COMP_LINE"]) result = argcomplete.split_line(comp_line, int(os.environ["COMP_POINT"]))[1] if "_ARGCOMPLETE_BENCHMARK" in os.environ: print("argcomplete_prefix =", result, file=sys.stderr) return result
def argcomplete_args() -> List[str]: args: List[str] = [] # Check if its auto completion # is_in_completion = False comp_line = os.environ.get("COMP_LINE", None) if comp_line is not None: # What is this COMP_POINT? comp_point = int(os.environ.get("COMP_POINT", 0)) # is_in_completion = True _, _, _, comp_words, _ = argcomplete.split_line(comp_line, comp_point) if not args: args = comp_words[1:] return args
def create_stack(): """ Create a stack from a template """ parser = argparse.ArgumentParser(description=create_stack.__doc__, add_help=False) _add_default_params(parser) parser.add_argument("-h", "--help", action='store_true') if "_ARGCOMPLETE" in os.environ: ac_args = argcomplete.split_line(os.environ['COMP_LINE'], os.environ['COMP_POINT'])[3] if len(ac_args) >= 2: template = ac_args[1] template_yaml = load_template(template) if template_yaml and "ContextClass" in template_yaml: context = load_class(template_yaml["ContextClass"])() context.add_context_arguments(parser) argcomplete.autocomplete(parser) args, _ = parser.parse_known_args() if args.template: template_yaml = load_template(args.template) if "ContextClass" in template_yaml: context = load_class(template_yaml["ContextClass"])() template_yaml.pop("ContextClass", None) parser = argparse.ArgumentParser(description=context.__doc__) _add_default_params(parser) context.add_context_arguments(parser) else: parser = argparse.ArgumentParser(description=create_stack.__doc__) _add_default_params(parser) else: parser = argparse.ArgumentParser(description=create_stack.__doc__) _add_default_params(parser) args = parser.parse_args() context.resolve_parameters(args) context.set_template(template_yaml) if context.write(yes=args.yes): subprocess.check_call([ "ndt", "print-create-instructions", context.component_name, context.stack_name ]) return
def wordbreak(self, line): return split_line(line)[4]
def prefix(self, line): return split_line(line)[1]
def __complete(self, line, parser): comp_line = line comp_point = len(line) cword_prequote, cword_prefix, cword_suffix, comp_words, first_colon_pos = argcomplete.split_line( comp_line, comp_point) # reset display strings for options self.option_display_str = [] # actions already chosen, we don't provide them anymore visited_actions = [] # list of possible completion values completions = [] # is the last action completed ? last_action_finished = True # are we completing a subcommand ? is_sub_command_active = False # the active sub command if any. sub_command_active = None # if the last word starts with a '-', it was an option, # we need to check if this option takes an argument if comp_words[-1].startswith(parser.prefix_chars): last_action_finished = False # collect visisted actions for action in parser._actions: if not isinstance(action, argparse._SubParsersAction): for option in action.option_strings: if option in line: visited_actions.append(action) # if last_action_finished is False, the last word was an option # then we check if the current option is this option # if so, we check if the option needs an argument if not last_action_finished and comp_words[ -1] in action.option_strings: if action.choices is not None: # last action was choices action, we return those choices for c in action.choices: if c.startswith(cword_prefix) or unicode( c).startswith(cword_prefix): completions.append(c) return completions elif isinstance(action, _FilePathAction): file_completion_result = self.__data_access_provider.complete( cword_prefix) # print file_completion_result completions.extend(file_completion_result) return completions if action.type is None: last_action_finished = True else: for subaction in action._get_subactions(): if subaction.dest in line: visited_actions.append(subaction.dest) is_sub_command_active = True sub_command_active = subaction.dest if not last_action_finished: if action.choices is not None: pass else: return [] # get options from parser if not is_sub_command_active: for action in parser._actions: if action not in visited_actions: # ensure it is no subparser instance if not isinstance(action, argparse._SubParsersAction): for option in action.option_strings: if option.startswith(cword_prefix): completions.append(option) else: for subaction in action._get_subactions(): if subaction.dest.startswith(cword_prefix): completions.append(subaction.dest) else: subparsers = parser._subparsers for action in subparsers._actions: if isinstance(action, argparse._SubParsersAction): for choice in action.choices: if choice == sub_command_active: subparser = action.choices[choice] completions += self.__complete(line, subparser) return completions
def add_subparsers_on_demand(parser, cli_name, dest, group_name, hide_extensions=None, required=True, argv=None): """ Create argparse subparser for each extension on demand. The ``cli_name`` is used for the title and description of the ``add_subparsers`` function call. For each extension a subparser is created is necessary. If no extension has been selected by command line arguments all first level extension must be loaded and instantiated. If a specific extension has been selected by command line arguments the sibling extension can be skipped and only that one extension (as well as potentially its recursive extensions) are loaded and instantiated. If the extension has an ``add_arguments`` method it is being called. :param parser: the parent argument parser :type parser: :py:class:`argparse.ArgumentParser` :param str cli_name: name of the command line command to which the subparsers are being added :param str dest: name of the attribute under which the selected extension will be stored :param str group_name: the name of the ``entry_point`` group identifying the extensions to be added :param list hide_extensions: an optional list of extension names which should be skipped :param bool required: a flag if the command is a required argument :param list argv: the list of command line arguments (default: ``sys.argv``) """ # add subparser without a description for now mutable_description = MutableString() subparser = parser.add_subparsers( title='Commands', description=mutable_description, metavar=f'Call `{cli_name} <command> -h` for more detailed usage.') # use a name which doesn't collide with any argument # but is readable when shown as part of the the usage information subparser.dest = ' ' + dest.lstrip('_') subparser.required = required # add entry point specific sub-parsers but without a description and # arguments for now entry_points = get_entry_points(group_name) command_parsers = {} for name in sorted(entry_points.keys()): command_parser = subparser.add_parser( name, formatter_class=argparse.RawDescriptionHelpFormatter) command_parsers[name] = command_parser # temporarily attach root parser to each command parser # in order to parse known args root_parser = getattr(parser, '_root_parser', parser) with SuppressUsageOutput({parser} | set(command_parsers.values())): args = argv # for completion use the arguments provided by the argcomplete env var if _is_completion_requested(): from argcomplete import split_line _, _, _, comp_words, _ = split_line(os.environ['COMP_LINE']) args = comp_words[1:] try: known_args, _ = root_parser.parse_known_args(args=args) except SystemExit: if not _is_completion_requested(): raise # if the partial arguments can't be parsed use no known args known_args = argparse.Namespace(**{subparser.dest: None}) # check if a specific subparser is selected name = getattr(known_args, subparser.dest) if name is None: # add description for all command extensions to the root parser command_extensions = get_command_extensions(group_name) if command_extensions: description = '' max_length = max( len(name) for name in command_extensions.keys() if hide_extensions is None or name not in hide_extensions) for name in sorted(command_extensions.keys()): if hide_extensions is not None and name in hide_extensions: continue extension = command_extensions[name] description += '%s %s\n' % (name.ljust(max_length), get_first_line_doc(extension)) command_parser = command_parsers[name] command_parser.set_defaults(**{dest: extension}) mutable_description.value = description else: # add description for the selected command extension to the subparser command_extensions = get_command_extensions( group_name, exclude_names=set(entry_points.keys() - {name})) extension = command_extensions[name] command_parser = command_parsers[name] command_parser.set_defaults(**{dest: extension}) command_parser.description = get_first_line_doc(extension) # add the arguments for the requested extension if hasattr(extension, 'add_arguments'): command_parser = command_parsers[name] command_parser._root_parser = root_parser signature = inspect.signature(extension.add_arguments) kwargs = {} if 'argv' in signature.parameters: kwargs['argv'] = argv extension.add_arguments(command_parser, f'{cli_name} {name}', **kwargs) del command_parser._root_parser return subparser