def main(): # Simple completion menu. print('(The completion menu displays colors.)') prompt('Type a color: ', completer=FuzzyCompleter(ColorCompleter())) # Multi-column menu. prompt('Type a color: ', completer=FuzzyCompleter(ColorCompleter()), complete_style=CompleteStyle.MULTI_COLUMN) # Readline-like prompt('Type a color: ', completer=FuzzyCompleter(ColorCompleter()), complete_style=CompleteStyle.READLINE_LIKE)
def __init__(self, words, meta_dict=None, WORD=False): # assert callable(words) or all(isinstance(w, string_types) for w in words) self.words = words self.meta_dict = meta_dict or {} self.WORD = WORD self.word_completer = WordCompleter( words=lambda: self.words, WORD=self.WORD, meta_dict=self.meta_dict ) self.fuzzy_completer = FuzzyCompleter(self.word_completer, WORD=self.WORD)
def run_cmd_shell(argv=[], prefix='cmd-> ', words=[], cmd_func=None): if len(argv) > 1 and cmd_func is not None: cmd_func(argv[1:]) return from prompt_toolkit import prompt, PromptSession from prompt_toolkit import PromptSession from prompt_toolkit.completion import WordCompleter from prompt_toolkit.lexers import PygmentsLexer from prompt_toolkit.styles import Style from pygments.lexers.sql import SqlLexer from prompt_toolkit.completion import FuzzyCompleter from prompt_toolkit.auto_suggest import AutoSuggestFromHistory _completer = FuzzyCompleter(WordCompleter(words)) session = PromptSession(lexer=PygmentsLexer(SqlLexer), completer=_completer, auto_suggest=AutoSuggestFromHistory()) while True: try: text = session.prompt(prefix) except KeyboardInterrupt: continue except EOFError: break else: args_str = text.strip() if args_str == '': continue args = args_str.split(' ') # print(args) if len(args) > 0 and cmd_func is not None: cmd_func(args)
def __init__(self) -> None: self.cli = None self.prompt_tokens = [] self.completer = FuzzyCompleter(CommandCompleter()) self.commands_repository = COMMANDS self.session = self.get_prompt_session()
def _exec_from_repl(self, theme=MonokaiTheme): self.do_repl = True manager_completer = FuzzyCompleter( CommandCompleter(self.manager, ignore_case=True)) lexer = create_lexer(commands=self.manager.command_names) session = PromptSession( completer=manager_completer, lexer=PygmentsLexer(lexer), style=theme.pygments_style(), ) while self.do_repl: try: user_input = u"{}".format(session.prompt(u">> ")) except KeyboardInterrupt: continue # Control-C pressed. Try again. except EOFError: break # Control-D Pressed. Finish try: command = user_input.split()[0] arguments = " ".join(user_input.split()[1:]) try: arguments = arguments.format(**self.context) except KeyError: pass args, kwargs = inline_parser(arguments) self._execute_command(command, *args, **kwargs) except Exception as error: print("Error executing: {}. Error: {}".format(command, error))
def __init__( self, words: List[str], display_dict: Optional[Dict[str, str]] = None, meta_dict: Optional[Dict[str, str]] = None, ) -> None: self.words = words self.WORD = True self.word_completer = WordCompleter( words=self.words, WORD=self.WORD, display_dict=display_dict, meta_dict=meta_dict, ) self.fuzzy_completer = FuzzyCompleter(self.word_completer, WORD=self.WORD)
def _maybe_complete_http_path( self, document: Document, complete_event: CompleteEvent, state_tracker: ParserStateTracker) -> Iterable[Completion]: tokens = state_tracker.tokens method_token, path_token = tokens[-2], tokens[-1] method = method_token.value.upper() cursor_position = document.cursor_position - path_token.index path = path_token.value[:cursor_position] _logger.debug(f'Completing HTTP API url: {path!r}') path_tokens = list(self.url_path_lexer.get_tokens_unprocessed(path)) _logger.debug(f'URL Path Tokens: {path_tokens}') if not path_tokens: # empty, should not happen return [] cursor_token = path_tokens[-1] _logger.debug(f'Cursor Token: {cursor_token}') if cursor_token.ttype is Error: return [] else: if cursor_token.ttype in (PathPart, Slash): complete_func = self.api_spec.complete_url_path elif cursor_token.ttype in (ParamName, QuestionMark, Ampersand): complete_func = self.api_spec.complete_query_param_name else: complete_func = self.api_spec.complete_query_param_value candidates = complete_func(document, complete_event, method, path_tokens) return FuzzyCompleter( ConstantCompleter(candidates)).get_completions( document, complete_event)
def add_workspace(self, initial=None, accept_all=False): if initial is None: initial = os.getcwd() else: initial = os.path.abspath(initial) existing_workspace = self.search_parent_in_workspaces(initial) if not existing_workspace: if accept_all: response = initial else: session = PromptSession(u"> ", completer=FuzzyCompleter( PathCompleter())) response = session.prompt( "Path to find new components\n> ", complete_while_typing=True, default=initial, pre_run=session.default_buffer.start_completion, validator=dir_validator) # Check the final '/' characters if response in self.workspace_paths: print(f"{response} already exist in workspaces") return new_components = self.get_recursive_components_in_dir(response) print("%s\n%d components found in %s" % (colored('\n'.join(new_components), 'green'), len(new_components), response)) if len(new_components) == 0: print( f"No component found in {response}. Workspaces not updated." ) return if accept_all: answer = True else: answer = confirm( f'Do you want to add {response} to workspaces?') if answer: print(f"{response} added to workspaces") self.components += new_components self.workspace_paths.append(response) self.save_workspace() else: print("Workspaces not updated.") else: print( f"{initial} is already part of an existing workspace ({existing_workspace})" ) self.update_components_in_workspaces(existing_workspace)
def main(args): if len(args) != 2: sys.stderr.write(f"Usage: {args[0]} <sqlite3 db>\n") sys.exit(1) base_completer = DirsCompleter(args[1]) completer = FuzzyCompleter(base_completer) session = PromptSession(HTML("<yellow>cd </yellow>"), completer=completer, complete_while_typing=True) try: answer = session.prompt(pre_run=session.default_buffer.start_completion) except KeyboardInterrupt: sys.exit(2) sys.stdout.write(answer)
def delete_workspace(self, keyword): session = PromptSession(u"> ", completer=FuzzyCompleter(WordCompleter(self.workspace_paths))) if not keyword: keyword = os.getcwd() else: keyword = os.path.abspath(keyword) response = session.prompt("Path to delete\n> ", complete_while_typing=True, default=keyword, pre_run=session.default_buffer.start_completion) if response in self.workspace_paths: self._delete_components_in_workspace(response) self.workspace_paths.remove(response) self.save_workspace()
def wait_command() -> None: global cmd_completer global prefix session = PromptSession(prefix, completer=FuzzyCompleter(cmd_completer), complete_while_typing=True, complete_in_thread=True, lexer=cmd_lexer, mouse_support=True, enable_history_search=True, auto_suggest=cmd_auto_suggest, history=cmd_history) while True: try: ipt = session.prompt() except KeyboardInterrupt: print(f"{Fore.LIGHTGREEN_EX}Bye.") break if any(ipt.startswith(match) for match in ["#", "//", '"', ";"]): continue elif ipt.startswith("/*") and not ipt.endswith("*/"): error("This comment block must be enclosed in */") elif ipt.startswith("/*") and ipt.endswith("*/"): continue start = time.perf_counter() try: cmd_completer.run_action(ipt) except ValueError: error("Command not found.") continue except TypeError: error("Argument(s) missing or invalid.") continue end = time.perf_counter() ok(end - start)
def _exec_from_repl(self, prompt=u'>> ', theme=MonokaiTheme, history_file=None): session_extra_options = {} if history_file: session_extra_options['history'] = FileHistory( os.path.expanduser(str(history_file))) self.do_repl = True manager_completer = FuzzyCompleter( CommandCompleter(self.manager, ignore_case=True)) lexer = create_lexer(commands=self.manager.command_names) session = PromptSession(completer=manager_completer, lexer=PygmentsLexer(lexer), style=theme.pygments_style(), **session_extra_options) while self.do_repl: try: user_input = u"{}".format(session.prompt(prompt)) except KeyboardInterrupt: continue # Control-C pressed. Try again. except EOFError: break # Control-D Pressed. Finish try: command_list = user_input.split() if not command_list: continue command = command_list[0] arguments = " ".join(command_list[1:]) try: arguments = arguments.format(**self.context) except KeyError: pass args, kwargs = inline_parser(arguments) self._execute_command(command, *args, **kwargs) except CommandNotFound: print('Command {} not found'.format(command)) if self.suggestions: possible_command = self.suggestions( command, self.manager.command_names) if possible_command: print('Did you mean: "{}"?'.format(possible_command)) except Exception as error: print("Error executing: {}. Error: {}".format(command, error))
def _maybe_complete_payload_value( self, document: Document, complete_event: CompleteEvent, state_tracker: ParserStateTracker) -> Iterable[Completion]: tokens = state_tracker.tokens _logger.debug(f'Completing for payload value with tokens: {tokens}') path_event = state_tracker.events[1] if path_event.token.ttype is not Literal: # No completion for non-literal URL return [] method_token, path_token = tokens[0], tokens[1] path_tokens = list( self.url_path_lexer.get_tokens_unprocessed(path_token.value)) last_event = state_tracker.last_event candidates, rules = self.api_spec.complete_payload_value( document, complete_event, method_token.value.upper(), path_tokens, tokens[tokens.index(last_event.token):], state_tracker.payload_events) if not candidates: return [] constant_completer = ConstantCompleter(candidates) return FuzzyCompleter(constant_completer).get_completions( document, complete_event)
def getTag(result): myComplete = {} myCompleteL = [] for r in result: if "tags" in path_entry_name_content[r]: if type(path_entry_name_content[r]["tags"]) == list: for i in path_entry_name_content[r]["tags"]: myComplete[i] = {} for i in myComplete: myCompleteL.append(i) #promptT = getPromptText() completer = FuzzyCompleter(WordCompleter(myCompleteL, ignore_case=True)) print(myCompleteL) icon = "search > tag >" if detectNerdFont: icon = " " session = PromptSession(icon + " ", style=style, key_bindings=bindings) #prompt= session.prompt(pre_run=session.default_buffer.start_completion,default="",completer=completer) prompt = session.prompt(pre_run=session.default_buffer.start_completion, default="", completer=completer)
class FuzzyWordCompleter(Completer): def __init__( self, words: List[str], display_dict: Optional[Dict[str, str]] = None, meta_dict: Optional[Dict[str, str]] = None, ) -> None: self.words = words self.WORD = True self.word_completer = WordCompleter( words=self.words, WORD=self.WORD, display_dict=display_dict, meta_dict=meta_dict, ) self.fuzzy_completer = FuzzyCompleter(self.word_completer, WORD=self.WORD) def get_completions(self, document: Document, complete_event: CompleteEvent) -> Iterable[Completion]: return self.fuzzy_completer.get_completions(document, complete_event) def get_completions_filtered( self, document: Document, complete_event: CompleteEvent, predicate: Callable[[Completion], bool], ) -> Iterable[Completion]: for v in self.get_completions(document, complete_event): if predicate(v): yield v def get_completions_without(self, document: Document, complete_event: CompleteEvent, **filter_values: bool) -> Iterable[Completion]: return self.get_completions_filtered( document, complete_event, lambda v: not filter_values.get(v.text, False))
class FuzzyWordCompleter(Completer): """ Fuzzy completion on a list of words. (This is basically a `WordCompleter` wrapped in a `FuzzyCompleter`.) :param words: List of words or callable that returns a list of words. :param meta_dict: Optional dict mapping words to their meta-information. :param WORD: When True, use WORD characters. """ def __init__(self, words, meta_dict=None, WORD=False): # assert callable(words) or all(isinstance(w, string_types) for w in words) self.words = words self.meta_dict = meta_dict or {} self.WORD = WORD self.word_completer = WordCompleter( words=lambda: self.words, WORD=self.WORD, meta_dict=self.meta_dict ) self.fuzzy_completer = FuzzyCompleter(self.word_completer, WORD=self.WORD) def get_completions(self, document, complete_event): return self.fuzzy_completer.get_completions(document, complete_event)
def _maybe_complete_payload( self, document: Document, complete_event: CompleteEvent, state_tracker: ParserStateTracker) -> Iterable[Completion]: tokens = state_tracker.tokens _logger.debug(f'Completing for payload with tokens: {tokens}') path_event = state_tracker.events[1] if path_event.token.ttype is not Literal: # No completion for non-literal URL return [] method_token, path_token = tokens[0], tokens[1] path_tokens = list( self.url_path_lexer.get_tokens_unprocessed(path_token.value)) last_event = state_tracker.last_event payload_tokens = tokens[tokens.index(last_event.token):] candidates, rules = self.api_spec.complete_payload( document, complete_event, method_token.value.upper(), path_tokens, payload_tokens) if not candidates: return [] constant_completer = ConstantCompleter(candidates) for c in FuzzyCompleter(constant_completer).get_completions( document, complete_event): yield PayloadKeyCompletion(c.text, rules[c.text], c.start_position, c.display, c.display_meta, c.style, c.selected_style)
def interactive_workspace_init(self, initial_path): def common_prefix(path_list): result = {} to_ignore = "" for path in sorted(path_list, reverse=True): path_parts = path.split('/') previous_counter = 0 previous_path = "" for part_index in range(len(path_parts)): counter = 0 last_path = '/'.join(path_parts[:len(path_parts) - part_index]) last_path = last_path[len(to_ignore):] if last_path and to_ignore + last_path not in result: for second_path in path_list: if last_path in second_path: counter += 1 if counter == previous_counter: del result[to_ignore + previous_path] previous_counter = counter previous_path = last_path if counter == len(path_list): to_ignore = to_ignore + last_path elif last_path and counter < len(path_list): result[to_ignore + last_path] = counter return result components_parents_dirs = self.get_recursive_components_in_dir( initial_path) # best_guess = common_prefix(list(components_parents_dirs.keys())) new_workspaces = [] print( f"Found {len(best_guess)} possibles components in {colored(initial_path, 'green')}" ) print(f"======") ignored = [] for path in sorted( best_guess, key=lambda x: calculate_path_value(x, best_guess[x]), reverse=True): print(len(path.split('/')) * best_guess[path]) end = False next = False for parent in new_workspaces: if path.startswith(parent): print( f"{colored(path, 'green')} ignored because you already selected parent {colored(parent, 'green')}" ) next = True break for parent in ignored: if path.startswith(parent): print( f"{colored(path, 'red')} ignored because you decided to ignore subdirs of {colored(parent, 'red')}" ) next = True break if next: continue while not end: print( f"Found {best_guess[path]} components in {colored(path, 'green')}" ) response = input( f"Do you wanna add to workspace? {colored('Yes/No/Ignore/End', 'cyan')} " ) if "yes" in response.lower() or "y" in response.lower(): new_workspaces.append(path) break if "ignore" in response.lower() or "i" in response.lower(): to_ignore = prompt('> ', completer=FuzzyCompleter( PathCompleter()), complete_while_typing=True, default=path) to_ignore = to_ignore.rstrip('/') if not to_ignore: to_ignore = path ignored.append(to_ignore) break elif "no" in response.lower() or "n" in response.lower(): break elif "end" in response.lower() or "e" in response.lower(): print("Finishing initialization of workspaces") end = True else: print('Invalid response (y/n/i/e)') if end: break self.workspace_paths = new_workspaces self.components = list( filter( lambda x: any( x.startswith(workspace) for workspace in self.workspace_paths), components_parents_dirs)) self.save_workspace()
cmd_unit = ctx.get_from_buffer('<complete>', doc) n = cmd_unit.root.lookup(lkql.Sloc(1, len(cmd_unit.text))) if n is None: return for sym in n.p_interp_complete: yield Completion(sym) if __name__ == '__main__': our_history = FileHistory(".example-history-file") session = PromptSession(history=our_history, lexer=PygmentsLexer(LKQLPygmentsLexer), completer=FuzzyCompleter(LKQLCompleter())) dummy_unit = ctx.get_from_buffer('<dummy>', '12') dummy_unit.root.p_interp_init_from_project( 'testsuite/ada_projects/deep_library/prj.gpr') while True: try: with patch_stdout(): cmd = session.prompt('> ') if cmd == 'exit': break cmd_unit = ctx.get_from_buffer('<repl_input>', cmd) print(cmd_unit.root.p_interp_eval)
def __init__( self, get_globals: Optional[_GetNamespace] = None, get_locals: Optional[_GetNamespace] = None, history_filename: Optional[str] = None, vi_mode: bool = False, color_depth: Optional[ColorDepth] = None, # Input/output. input: Optional[Input] = None, output: Optional[Output] = None, # For internal use. extra_key_bindings: Optional[KeyBindings] = None, _completer: Optional[Completer] = None, _validator: Optional[Validator] = None, _lexer: Optional[Lexer] = None, _extra_buffer_processors=None, _extra_layout_body=None, _extra_toolbars=None, _input_buffer_height=None, ) -> None: self.get_globals: _GetNamespace = get_globals or (lambda: {}) self.get_locals: _GetNamespace = get_locals or self.get_globals self._completer = _completer or FuzzyCompleter( PythonCompleter( self.get_globals, self.get_locals, lambda: self.enable_dictionary_completion, ), enable_fuzzy=Condition(lambda: self.enable_fuzzy_completion), ) self._validator = _validator or PythonValidator( self.get_compiler_flags) self._lexer = _lexer or PygmentsLexer(PythonLexer) self.history: History if history_filename: self.history = ThreadedHistory(FileHistory(history_filename)) else: self.history = InMemoryHistory() self._input_buffer_height = _input_buffer_height self._extra_layout_body = _extra_layout_body or [] self._extra_toolbars = _extra_toolbars or [] self._extra_buffer_processors = _extra_buffer_processors or [] self.extra_key_bindings = extra_key_bindings or KeyBindings() # Settings. self.title: AnyFormattedText = "" self.show_signature: bool = False self.show_docstring: bool = False self.show_meta_enter_message: bool = True self.completion_visualisation: CompletionVisualisation = CompletionVisualisation.MULTI_COLUMN self.completion_menu_scroll_offset: int = 1 self.show_line_numbers: bool = False self.show_status_bar: bool = True self.wrap_lines: bool = True self.complete_while_typing: bool = True self.paste_mode: bool = False # When True, don't insert whitespace after newline. self.confirm_exit: bool = True # Ask for confirmation when Control-D is pressed. self.accept_input_on_enter: int = 2 # Accept when pressing Enter 'n' times. # 'None' means that meta-enter is always required. self.enable_open_in_editor: bool = True self.enable_system_bindings: bool = True self.enable_input_validation: bool = True self.enable_auto_suggest: bool = False self.enable_mouse_support: bool = False self.enable_history_search: bool = False # When True, like readline, going # back in history will filter the # history on the records starting # with the current input. self.enable_syntax_highlighting: bool = True self.enable_fuzzy_completion: bool = False self.enable_dictionary_completion: bool = False self.swap_light_and_dark: bool = False self.highlight_matching_parenthesis: bool = False self.show_sidebar: bool = False # Currently show the sidebar. # When the sidebar is visible, also show the help text. self.show_sidebar_help: bool = True # Currently show 'Do you really want to exit?' self.show_exit_confirmation: bool = False # The title to be displayed in the terminal. (None or string.) self.terminal_title: Optional[str] = None self.exit_message: str = "Do you really want to exit?" self.insert_blank_line_after_output: bool = True # (For the REPL.) # The buffers. self.default_buffer = self._create_buffer() self.search_buffer: Buffer = Buffer() self.docstring_buffer: Buffer = Buffer(read_only=True) # Tokens to be shown at the prompt. self.prompt_style: str = "classic" # The currently active style. # Styles selectable from the menu. self.all_prompt_styles: Dict[str, PromptStyle] = { "ipython": IPythonPrompt(self), "classic": ClassicPrompt(), } self.get_input_prompt = lambda: self.all_prompt_styles[ self.prompt_style].in_prompt() self.get_output_prompt = lambda: self.all_prompt_styles[ self.prompt_style].out_prompt() #: Load styles. self.code_styles: Dict[str, BaseStyle] = get_all_code_styles() self.ui_styles = get_all_ui_styles() self._current_code_style_name: str = "default" self._current_ui_style_name: str = "default" if is_windows(): self._current_code_style_name = "win32" self._current_style = self._generate_style() self.color_depth: ColorDepth = color_depth or ColorDepth.default() self.max_brightness: float = 1.0 self.min_brightness: float = 0.0 # Options to be configurable from the sidebar. self.options = self._create_options() self.selected_option_index: int = 0 #: Incremeting integer counting the current statement. self.current_statement_index: int = 1 # Code signatures. (This is set asynchronously after a timeout.) self.signatures: List[Any] = [] # Boolean indicating whether we have a signatures thread running. # (Never run more than one at the same time.) self._get_signatures_thread_running: bool = False self.style_transformation = merge_style_transformations([ ConditionalStyleTransformation( SwapLightAndDarkStyleTransformation(), filter=Condition(lambda: self.swap_light_and_dark), ), AdjustBrightnessStyleTransformation(lambda: self.min_brightness, lambda: self.max_brightness), ]) self.ptpython_layout = PtPythonLayout( self, lexer=DynamicLexer(lambda: self._lexer if self. enable_syntax_highlighting else SimpleLexer()), input_buffer_height=self._input_buffer_height, extra_buffer_processors=self._extra_buffer_processors, extra_body=self._extra_layout_body, extra_toolbars=self._extra_toolbars, ) self.app = self._create_application(input, output) if vi_mode: self.app.editing_mode = EditingMode.VI
return result output_field = TextArea(style="class:output-field", text=help_text) output_field_2 = TextArea(style="class:output-field", text=help_text) search_field = SearchToolbar() input_field = TextArea(height=2, prompt=">>> ", style="class:input-field", multiline=False, wrap_lines=False, search_field=search_field, completer=FuzzyCompleter(ColorCompleter(), enable_fuzzy=False)) def accept(buff): # Evaluate "calculator" expression. try: #output = "\n\nIn: {}\nOut: {}".format( # input_field.text, eval(input_field.text) #) # Don't do 'eval' in real code! output = "You're typing " + input_field.text + "\n" if input_field.text == "info": do_about() if input_field.text == "exit": do_exit() except BaseException as e: output = "\n\n{}".format(e)
# dataDemo = {**dataDemo , **dataDemoModules } for m in plugins.Plugin.pluginsActivated: print(m) dataDemoModules = {} dataDemoModules = yaml.load( plugins.Plugin.pluginsActivated[m].getDemoDataYaml(), Loader=yaml.SafeLoader) dataDemo = {**dataDemo, **dataDemoModules} if os.getenv("ST_DEMO") == '1': my_fun(dataDemo, menu_completion, "", "") else: my_fun(jinjaFile2yaml(file_main), menu_completion, "", "") completer = FuzzyCompleter(NestedCompleter.from_nested_dict(menu_completion)) def getIcon(icon, defaultIcon=""): if detectNerdFont: return icon return defaultIcon bindings = KeyBindings() @bindings.add('c-c') def _(event): #" Exit when `c-x` is pressed. " event.app.exit()
def main(): global fire_obj last_command = [] args = parse_args(sys.argv[1:]) args_data = args.data args_data.append("-") history_file = config.history_path session = PromptSession( history=FileHistory(history_file), style=get_style(), wrap_lines=True, auto_suggest=AutoSuggestFromHistory(), ) try: while True: prompt = session.prompt( prompt_message(fire_obj=fire_obj), bottom_toolbar=bottom_toolbar(fire_obj), completer=FuzzyCompleter( merge_completers([CustomCompleter(), chepy_cli.CliCompleter()]) ), validator=CustomValidator(), rprompt=get_current_type(fire_obj), ) # check and output any commands that start with cli_ if re.match(r"^\!", prompt): print(subprocess.getoutput(re.sub(r"^\!\s?", "", prompt))) elif re.search(r"^cli_.+", prompt): cli_method = prompt.split()[0] cli_args = re.search(r"--(\w+)\s(\w+)", prompt) if cli_method == "cli_show_errors": getattr(chepy_cli, "cli_show_errors")(errors) elif cli_method == "cli_go_back": args_data = args_data[: -len(last_command + ["-"])] print(cyan("Go back: {}".format(last_command))) elif cli_method == "cli_delete_history": Path(config.history_path).unlink() elif cli_args: getattr(chepy_cli, cli_method)( fire_obj, **{cli_args.group(1): cli_args.group(2)} ) else: getattr(chepy_cli, cli_method)(fire_obj) else: for method in chepy: if not method.startswith("_") and not isinstance( getattr(Chepy, method), property ): fire.decorators._SetMetadata( getattr(Chepy, method), fire.decorators.ACCEPTS_POSITIONAL_ARGS, False, ) args_data += prompt.split() if args_data[-1] != "-": args_data.append("-") try: last_command = prompt.split() + ["-"] fire_obj = fire.Fire(Chepy, command=args_data) except: # go back to last working arg e_type, e_msg, e_traceback = sys.exc_info() print(red(e_type.__name__), yellow(e_msg.__str__())) args_data = args_data[: -len(last_command)] continue except KeyboardInterrupt: print("OKBye") sys.exit()
def loop(stub, modules, module, netif, hostif): session = PromptSession() while True: p = "> " if module: loc = module.location p = "module({})> ".format(loc) if netif: p = "module({})/netif({})> ".format(loc, netif.index) elif hostif: p = "module({})/hostif({})> ".format(loc, hostif.index) c = FuzzyCompleter( TAIShellCompleter(stub, modules, module, netif, hostif)) line = session.prompt(p, completer=c).strip() cmds = [e.strip() for e in line.split()] if len(cmds) == 0: continue cmd = cmds[0] try: if cmd == 'module': if len(cmds) != 2: print('invalid input: module <location>') continue loc = cmds[1] if loc not in modules: print('no module whose location is {}'.format(loc)) continue module = modules[loc] netif = None hostif = None elif cmd == 'netif' or cmd == 'hostif': if not module: print('no module selected.') continue if len(cmds) != 2: print('invalid input: {} <index>'.format(cmd)) continue index = int(cmds[1]) l = module.netifs if cmd == 'hostif': l = module.hostifs if len(l) < index: print('invalid index: len: {}'.format(len(l))) continue if cmd == 'netif': netif = l[index] hostif = None else: hostif = l[index] netif = None elif cmd == 'list': show_modules(modules) elif cmd == 'list-attr': list_attr(stub, module, netif, hostif) elif cmd == 'get': print(get_attr(stub, module, netif, hostif, cmds)) elif cmd == 'set': set_attr(stub, module, netif, hostif, cmds) elif cmd == 'monitor': monitor(stub, module, netif, hostif, cmds) elif cmd == 'log-level': set_log_level(stub, cmds) elif cmd in ['exit', 'quit', 'q']: if netif: netif = None elif hostif: hostif = None elif module: module = None else: sys.exit(0) elif cmd in ['help', 'h', '?']: show_help() else: print('unknown cmd: {}'.format(cmd)) show_help() except Exception as e: print(e)
def make_prompt_session(): commands = focus.commands class CustomComplete(Completer): def get_completions(self, document, complete_event): word = document.get_word_before_cursor() words = document.text.split() complete_words = (words if document.text.endswith(' ') else words[:-1]) if words and words[0] in ['subtask-by-id', 'switch-task']: if len(complete_words) >= 2: return for task in the_tree.root_nodes_iter(): if str(task.id).startswith(word): yield Completion(str(task.id), display=f'{task.id} : {task.text}', start_position=-len(word)) else: if len(complete_words) >= 1: return for command in list(commands): if command.startswith(word): yield Completion(command, display=command + ' : ' + commands[command]['help'], start_position=-len(word)) ft_completer = FuzzyCompleter(CustomComplete()) # This if I want the help to be displayed ft_completer = CustomComplete() #################################################################################### # commands = focus.commands # meta_dict = {c : commands[c]['help'] for c in commands} # #print(meta_dict) # ft_completer = WordCompleter(focus.commands, meta_dict=meta_dict) prompt_style = Style.from_dict({'prompt': '#00aa00'}) prompt_string = [('class:username', 'FocusTree> ')] bindings = KeyBindings() @bindings.add('c-j') def _(event): event.current_buffer.complete_next() @bindings.add('c-k') def _(event): event.current_buffer.complete_previous() # @bindings.add('tab') # def _(event): # # THIS IS THE GETTO-EST THING EVER, DON'T JUDGE ME! # # I just want it to select the currently highlighted # # completion. It could continue completing after. # current_buffer = event.app.current_buffer # compl = current_buffer.text # current_buffer.cancel_completion() # current_buffer.text = '' # current_buffer.insert_text(compl + ' ') prompt_sesh = PromptSession(history=FileHistory( os.path.expanduser('~/.focus_tree_history')), auto_suggest=AutoSuggestFromHistory(), completer=ft_completer, reserve_space_for_menu=8, lexer=PygmentsLexer(BashLexer), key_bindings=bindings, style=prompt_style, complete_style=CompleteStyle.COLUMN) def prompt(): return prompt_sesh.prompt([('class:username', 'FocusTree> ')]) return prompt
def __init__(self, session, parent, name, type_): self.type_ = type_ self.name = name self._get_hook = {} self._set_hook = {} self.session = session super(TAIObject, self).__init__(parent) d = self.session.get_context().get_searchdirs() repo = repository.FileRepository(d[0]) ctx = context.Context(repo) m = self.session.get_context().get_module('goldstone-tai') v = m.print_mem(ly.LYS_IN_YANG, 0) ctx.add_module(None, v) mod = ctx.get_module('goldstone-tai') self.config = mod.search_one('grouping', 'tai-{}-config'.format(type_)) self.state = mod.search_one('grouping', 'tai-{}-state'.format(type_)) @self.command(FuzzyCompleter(TAICompleter(self.config, self.state))) def get(args): if len(args) != 1: raise InvalidInput('usage: get <name>') self.session.session_switch_ds(sr.SR_DS_OPERATIONAL) try: items = self.session.get_items('{}/state/{}'.format( self.xpath(), args[0])) for i in range(items.val_cnt()): item = items.val(i) if args[0] in self._get_hook: print(self._get_hook[args[0]](item)) else: print(item.val_to_string()) except RuntimeError: err = self.session.get_error() if err.error_cnt() > 0: idx = err.error_cnt() - 1 print('err: {}, xpath: {}'.format(err.message(idx), err.xpath(idx))) self.session.session_switch_ds(sr.SR_DS_RUNNING) @self.command(TAICompleter(self.config)) def set(args): if len(args) != 2: raise InvalidInput('usage: set <name> <value>') if args[0] in self._set_hook: v = self._set_hook[args[0]](args[1]) else: v = args[1] self.session.set_item_str( '{}/config/{}'.format(self.xpath(), args[0]), v) self.session.apply_changes() @self.command() def show(args): if len(args) != 0: raise InvalidInput('usage: show[cr]') self.session.session_switch_ds(sr.SR_DS_OPERATIONAL) tree = self.session.get_subtree(self.xpath(), TIMEOUT_MS) d = json.loads(tree.print_mem(ly.LYD_JSON, 0)) print(d) self.session.session_switch_ds(sr.SR_DS_RUNNING)
def get_completer(): csv_files = [s for s in listdir() if s.endswith('.csv')] completions['load'] = WordCompleter(csv_files) completer = NestedCompleter.from_nested_dict(completions) return FuzzyCompleter(completer)
def main(): global fire_obj last_command = [] args = parse_args(sys.argv[1:]) args_data = args.data if args.recipe: print(Chepy(*args_data).load_recipe(args.recipe).o) else: args_data.append("-") history_file = config.history_path session = PromptSession( history=FileHistory(history_file), style=get_style(), wrap_lines=True, auto_suggest=AutoSuggestFromHistory(), ) try: while True: prompt = session.prompt( prompt_message(fire_obj=fire_obj), bottom_toolbar=bottom_toolbar(fire_obj), completer=FuzzyCompleter( merge_completers([CustomCompleter(), chepy_cli.CliCompleter()]) ), validator=CustomValidator(), rprompt=get_current_type(fire_obj), ) # check and output any commands that start with cli_ if re.match(r"^\!", prompt): print(magenta(subprocess.getoutput(re.sub(r"^\!\s?", "", prompt)))) # check if line is a comment elif re.match(r"^#", prompt): print(cyan(prompt)) # get help for a method elif re.match(r"^\?", prompt): _method_name = re.match(r"^\?(\s?)+([\w_]+)", prompt).group(2) chepy_cli.get_doc(_method_name) # check if method called is a cli method elif re.search(r"^cli_.+", prompt): cli_method = prompt.split()[0] cli_args = re.search(r"--(\w+)\s([\w\W]+)", prompt) # Show errors encountered if cli_method == "cli_show_errors": getattr(chepy_cli, "cli_show_errors")(errors) # show the current plugin path elif cli_method == "cli_plugin_path": getattr(chepy_cli, "cli_plugin_path")(config) # Edit the current state elif cli_method == "cli_edit_state": try: getattr(chepy_cli, "cli_edit_state")(fire_obj, args_data) args_data = args_data[0 : args_data.index("-")] + ["-"] except: e_type, e_msg, e_traceback = sys.exc_info() print(red(e_type.__name__), yellow("Could not edit state")) # Go back one step elif cli_method == "cli_go_back": args_data = args_data[: -len(last_command + ["-"])] print(cyan("Go back: {}".format(last_command))) # Delete the cli history file elif cli_method == "cli_delete_history": Path(config.history_path).unlink() elif cli_args: getattr(chepy_cli, cli_method)( fire_obj, **{cli_args.group(1): cli_args.group(2)} ) else: getattr(chepy_cli, cli_method)(fire_obj) else: for method in chepy: if not method.startswith("_") and not isinstance( getattr(Chepy, method), property ): fire.decorators._SetMetadata( getattr(Chepy, method), fire.decorators.ACCEPTS_POSITIONAL_ARGS, False, ) args_data += prompt.split() if args_data[-1] != "-": args_data.append("-") try: last_command = prompt.split() + ["-"] fire_obj = fire.Fire(Chepy, command=args_data) # handle required args for methods except fire.core.FireExit: args_data = args_data[: -len(last_command)] except TypeError as e: print(red(e.message)) except SystemExit: sys.exit() except: # go back to last working arg e_type, e_msg, e_traceback = sys.exc_info() print(red(e_type.__name__), yellow(e_msg.__str__())) args_data = args_data[: -len(last_command)] continue except KeyboardInterrupt: print(green("\nOKBye")) sys.exit()
def __init__(self, conn, parent, name, type_): self.type_ = type_ self.name = name self._get_hook = {} self._set_hook = {} self.session = conn.start_session() super(TAIObject, self).__init__(parent) d = self.session.get_ly_ctx().get_searchdirs() repo = repository.FileRepository(d[0]) ctx = context.Context(repo) m = self.session.get_ly_ctx().get_module('goldstone-tai') v = m.print_mem("yang") ctx.add_module(None, v) mod = ctx.get_module('goldstone-tai') self.config = mod.search_one('grouping', 'tai-{}-config'.format(type_)) self.state = mod.search_one('grouping', 'tai-{}-state'.format(type_)) @self.command(FuzzyCompleter(TAICompleter(self.config, self.state))) def get(args): if len(args) != 1: raise InvalidInput('usage: get <name>') self.session.switch_datastore('operational') try: items = self.session.get_items('{}/state/{}'.format( self.xpath(), args[0])) for item in items: if args[0] in self._get_hook: print(self._get_hook[args[0]](item.value)) else: print(item.value) except sr.errors.SysrepoCallbackFailedError as e: print(e) @self.command(TAICompleter(self.config)) def set(args): if len(args) != 2: raise InvalidInput('usage: set <name> <value>') if args[0] in self._set_hook: v = self._set_hook[args[0]](args[1]) else: v = args[1] self.session.switch_datastore('running') if type(self) != Module: try: self.session.get_data(self.parent.xpath()) except sr.SysrepoNotFoundError: self.session.set_item(f'{self.parent.xpath()}/config/name', self.parent.name) try: self.session.get_data(self.xpath()) except sr.SysrepoNotFoundError: self.session.set_item(f'{self.xpath()}/config/name', self.name) self.session.set_item(f'{self.xpath()}/config/{args[0]}', v) self.session.apply_changes() @self.command() def show(args): if len(args) != 0: raise InvalidInput('usage: show[cr]') self.session.switch_datastore('operational') print(self.session.get_data(self.xpath())) self.session.switch_datastore('running')