def powercmd_complete(text): from powercmd.utils import match_instance, get_available_instance_names from powercmd.match_string import match_string paren_idx = text.find('(') if paren_idx >= 0: # argument completion opt_name = text[:paren_idx] if opt_name == 'Option': ctor = Option else: ctor = match_instance(Option, text[:paren_idx], match_extra_cls=[OptionConstructor]) if not ctor: return [] elif isinstance(ctor, OptionConstructor): ctor = ctor.content_mapper sig = inspect.signature(ctor) # the '' is a hack to prevent Cmd from actually inserting the completion return ['', str(sig)] possible = get_available_instance_names(Option, match_extra_cls=[OptionConstructor], append_paren_to_callables=True) return match_string(text, possible)
def powercmd_complete(text): from powercmd.utils import match_instance, get_available_instance_names from powercmd.match_string import match_string paren_idx = text.find('(') if paren_idx >= 0: # argument completion opt_name = text[:paren_idx] if opt_name == 'Option': ctor = Option else: ctor = match_instance(Option, text[:paren_idx], match_extra_cls=[OptionConstructor]) if not ctor: return [] if isinstance(ctor, OptionConstructor): ctor = ctor.content_mapper sig = inspect.signature(ctor) # the '' is a hack to prevent Cmd from actually inserting the completion return ['', str(sig)] possible = get_available_instance_names(Option, match_extra_cls=[OptionConstructor], append_paren_to_callables=True) return match_string(text, possible)
def _complete_commands(self, incomplete_cmd: str) -> Sequence[Completion]: """ Returns a sequence of command completions matching INCOMPLETE_CMD prefix. """ matching_cmds = (self._cmds[cmd] for cmd in match_string(incomplete_cmd, self._cmds)) yield from (Completion(cmd.name, start_position=-len(incomplete_cmd), display_meta=cmd.short_description) for cmd in matching_cmds)
def powercmd_complete(text): """ If a type has a static powercmd_complete method, it's called to get a list of possible autocompletions for given input TEXT. powercmd.match_string contains match_string and simple_match_string functions that may be used to filter a list of possibilities using various match strategies (like e.g. fuzzy search). """ return match_string(text, ['first_completion', 'second_completion'])
def choose(self, short_cmd: str, verbose: bool = False) -> Command: """Returns a command handler that matches SHORT_CMD.""" matches = match_string(short_cmd, self, verbose=verbose) if not matches: raise InvalidInput('no such command: %s' % (short_cmd, )) if len(matches) > 1: raise InvalidInput('ambigious command: %s (possible: %s)' % (short_cmd, ' '.join(matches))) return self[matches[0]]
def _complete_enum(enum_hint: type, incomplete_value: str): """ Returns completions for an class derived from enum.Enum type. """ matching_names = match_string(incomplete_value, (val.name for val in list(enum_hint))) matching_vals = (enum_hint[name] for name in matching_names) yield from (Completion(val.name, start_position=-len(incomplete_value), display_meta=str(val.value)) for val in matching_vals)
def _complete_params(cmd: Command, incomplete_param: str) -> Sequence[Completion]: """ Returns a sequence of parameter name completions matching INCOMPLETE_PARAM prefix for given CMD. """ matching_params = (cmd.parameters[param] for param in match_string(incomplete_param, cmd.parameters)) yield from (Completion(param.name, start_position=-len(incomplete_param), display_meta=str(param.type)) for param in matching_params)
def choose(self, short_cmd: str, verbose: bool = False) -> Command: """Returns a command handler that matches SHORT_CMD.""" matches = match_string(short_cmd, self, verbose=verbose) if not matches: raise InvalidInput('no such command: %s' % (short_cmd,)) elif len(matches) > 1: raise InvalidInput('ambigious command: %s (possible: %s)' % (short_cmd, ' '.join(matches))) else: return self[matches[0]]
def _choose_cmd_handler(self, cmds: Mapping[str, Callable], short_cmd: str, verbose: bool = False) -> Callable: """Returns a command handler that matches SHORT_CMD.""" matches = match_string(short_cmd, cmds, verbose=verbose) if not matches: raise Cmd.SyntaxError('no such command: %s' % (short_cmd, )) elif len(matches) > 1: raise Cmd.SyntaxError('ambigious command: %s (possible: %s)' % (short_cmd, ' '.join(matches))) else: return cmds[matches[0]]
def _choose_cmd_handler(self, cmds: Mapping[str, Callable], short_cmd: str, verbose: bool=False) -> Callable: """Returns a command handler that matches SHORT_CMD.""" matches = match_string(short_cmd, cmds, verbose=verbose) if not matches: raise Cmd.SyntaxError('no such command: %s' % (short_cmd,)) elif len(matches) > 1: raise Cmd.SyntaxError('ambigious command: %s (possible: %s)' % (short_cmd, ' '.join(matches))) else: return cmds[matches[0]]
def _complete_impl(self, line: str, possibilities: OrderedMapping[str, inspect.Parameter]) -> List[str]: """ Returns the list of possible tab-completions for given LINE. """ words = line.split(' ') if words and '=' in words[-1] and line[-1] not in string.whitespace: try: key, val = words[-1].split('=', maxsplit=1) try: completer = self.get_completer(possibilities[key].annotation) return list(completer(val)) except AttributeError as e: pass except ValueError as e: print(e) matches = match_string(words[-1], possibilities) return [x + '=' for x in matches]
def powercmd_complete(text): from powercmd.utils import get_available_instance_names from powercmd.match_string import match_string possible = get_available_instance_names(ContentFormatOption) return match_string(text, possible)
def powercmd_complete(text): from powercmd.utils import get_available_instance_names from powercmd.match_string import match_string possible = get_available_instance_names(Code) return match_string(text, possible)
def powercmd_complete(text): possible = get_available_instance_names(ContentFormatOption) return match_string(text, possible)
def powercmd_complete(text): from powercmd.match_string import match_string return match_string(text, ResourceType.TYPES.keys())