def get_completers(cls): commands = [ c.get_completer() for c in {cmd for k, cmd in cls._supported_commands.items() if k} ] return merge_completers(commands)
def main(): completer = merge_completers([animal_completer, color_completer]) text = prompt('Give some animals: ', completer=completer, complete_while_typing=False) print('You said: %s' % text)
def create_completer(deduplicate: bool): return merge_completers( [ WordCompleter(["hello", "world", "abc", "def"]), WordCompleter(["xyz", "xyz", "abc", "def"]), ], deduplicate=deduplicate, )
def prepare_completers(commands): completer_commands = WordCompleter(commands) repos = [str(r.parts[-1:][0]) for r in list_all_repos()] completer_repos = WordCompleter(repos) completer_files = PathCompleter( file_filter=lambda filename: str(filename).endswith('.csv'), min_input_len=0, get_paths=lambda: [current_path]) return merge_completers( [completer_commands, completer_repos, completer_files])
def _maybe_complete_for_type( self, annotation: Any, document: Document, complete_event: CompleteEvent ) -> Iterable[Completion]: for _type, completers in self._app.type_completer_mapping.items(): if is_matching_type(_type, annotation): yield from merge_completers(completers).get_completions( document, complete_event )
def getCommandCompleter() -> prompt_toolkit.completion.Completer: from prompt_toolkit.completion import WordCompleter, merge_completers cmdLists = list(builtinCmdLists) man = shared.getManager() if man: cmdLists += man.importedCommand.keys() else: cmdLists += defaultData.importedCommand wc = WordCompleter(cmdLists, ignore_case=True) pc = ui.PathCompleter() return merge_completers([wc, pc])
def direct_completers() -> Completer: def allowed_arg(arg_info: ArgInfo) -> bool: group = arg_info.option_group return group is None or not any(a.arg.name in parts for a in self.args.values() if a.arg.option_group == group) d = [ a.completer for a in self.direct if a.completer if allowed_arg(a.arg) ] return merge_completers(d)
def main(script, debug, vi, multiline, record): """A gnuplot shell """ logging.basicConfig(level=logging.WARNING) logger = logging.getLogger(__name__) if debug: logger.setLevel(logging.DEBUG) logger.debug("Enabled debug output") print(''' If you press Control-x Control-e, the prompt will open in $EDITOR. Auto-suggestion accept pressing right arrow. Auto completion using TAB Exit by pressing Control-d ''') config_file = os.path.expanduser('~/.ignuplotrc.py') if os.path.exists(config_file): logger.debug('Executinb configuration file {0}'.format(config_file)) with open(config_file) as fd: exec(fd.read()) logger.debug('Using gnuplot binary in {0}'.format( ignuplot.config.GNUPLOT_BINARY)) pathcompleter = PathCompleter(expanduser=True) completer = merge_completers([pathcompleter, gnuplot_keyword_completer]) style = ignuplot.style.ignuplot_style repl = ignuplot.repl.Shell(vi_mode=vi, multiline=multiline, style=style, completer=completer) if script is not None and os.path.exists(script): with open(script) as fd: text = fd.read() repl.lines = [text] repl.history.append_string(text) repl.digest() returncode = repl.run() if record: with open(script, 'a+') as fd: for line in repl.lines: fd.write('{0}\n'.format(line)) return returncode
def __init__(self, kinds: List[str], props: List[str], with_as: bool = True) -> None: super().__init__(kinds, props) self.comma_var_completer = FuzzyWordCompleter( [","], meta_dict=({ ",": "define another variable" }), ) self.props_completer = self.property_names_completer self.group_after_name = (merge_completers([ self.as_completer, self.comma_var_completer ]) if with_as else self.comma_var_completer) self.after_group = self.comma_var_completer
def get_completions(self, document: Document, complete_event: CompleteEvent) -> Iterable[Completion]: # Split document. text = document.text_before_cursor.lstrip() stripped_len = len(document.text_before_cursor) - len(text) # If there is a space, check for the first term, and use a # subcompleter. if " " in text: first_term = text.split()[0] command = self.description.get(first_term) # If we have a sub completer, use this for the completions. if command is not None: options = [k for k in command if k != "positional"] terms = text.split(" ") if len(terms) > 2: prev_term = terms[-2] else: prev_term = None if prev_term in options: completer = command[prev_term] else: positionals = command.get("positional", []) completer = merge_completers( [WordCompleter(options, ignore_case=False)] + positionals) for c in completer.get_completions(document, complete_event): yield c # No space in the input: behave exactly like `WordCompleter`. else: completer = WordCompleter(list(self.description.keys()), ignore_case=False) for c in completer.get_completions(document, complete_event): yield c
def __init__(self, kinds: List[str], props: List[str]) -> None: super().__init__(kinds, props) self.aggregate_fns = ["sum(", "min(", "max(", "avg("] self.aggregate_fn_completer = FuzzyWordCompleter( self.aggregate_fns, meta_dict={ "sum(": "sum over all occurrences", "min(": "use the smallest occurrence", "max(": "use the biggest occurrence", "avg(": "average over all occurrences", }, ) self.as_completer = FuzzyWordCompleter(["as"], meta_dict=({ "as": "rename this result" })) self.colon_completer = FuzzyWordCompleter( [":"], meta_dict=({ ":": "to define functions for this group" }), ) self.comma_var_completer = FuzzyWordCompleter( [","], meta_dict=({ ",": "define another group variable" }), ) self.comma_fn_completer = FuzzyWordCompleter( [","], meta_dict=({ ",": "define another group function" }), ) self.props_completer = FuzzyWordCompleter( props + [ "/ancestors.", "/reported.", "/desired.", "/metadata.", "/descendants." ], meta_dict=({ "/reported.": "absolute path in reported section", "/desired.": "absolute path in desired section", "/metadata.": "absolute path in metadata section", "/ancestors.": "on ancestor properties", "/descendants.": "on descendant properties", **{p: "aggregate property" for p in self.props}, }), ) self.group_with_value_completer = merge_completers([ HintCompleter("1", "Static value to count", "1"), self.props_completer ]) self.group_after_name = merge_completers([ self.as_completer, self.colon_completer, self.comma_var_completer ]) self.fn_after_name = merge_completers( [self.as_completer, self.comma_fn_completer]) self.after_group = merge_completers( [self.comma_var_completer, self.colon_completer]) self.after_fn_completer = merge_completers( [self.as_completer, self.comma_fn_completer]) self.hint_completer = HintCompleter( "Example", "aggregation example", "kind, volume_type as type: sum(volume_size) as volume_size", ) self.with_hint_completer = merge_completers([ self.hint_completer, self.props_completer, self.aggregate_fn_completer ]) self.value_hint_completer = HintCompleter("<name>", "name of this result")
# (We don't add them to the `completion`. Users can type it # to trigger the autocompletion themselves.) filename += '/' elif self.only_directories: continue if not self.file_filter(full_name): continue yield Completion(completion, 0, display=filename) except OSError: pass pathcompleter = PathCompleter(expanduser=False) completer = merge_completers([pathcompleter, wordcompleter]) style = style_from_pygments_cls(MyGpStyle) def prompt_info(text): print_formatted_text(HTML('<green>{0}</green>').format(text)) def prompt_error(text): print_formatted_text(HTML('<red>{0}</red>').format(text)) def gnuplot(lines): import subprocess proc = subprocess.Popen(
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()
"name": dict(history=InMemoryHistory()), "action_template_id": dict(history=InMemoryHistory(), completer=action_completer), "stop_on_error": dict(validator=v.Bool, converter=c.Bool, history=InMemoryHistory()), "stop_undo_on_error": dict(validator=v.Bool, converter=c.Bool, history=InMemoryHistory()), "undo_on_error": dict(validator=v.Bool, converter=c.Bool, history=InMemoryHistory()), "action_type": dict(validator=v.Choice([at.name for at in ActionType if at.name != 'NATIVE']), history=InMemoryHistory()), "code": dict(edit=code_extension, history=InMemoryHistory(), converter=c.MultiLine), "expected_stdout": dict(multiline=True, mouse_support=True, history=InMemoryHistory(), converter=c.MultiLine), "expected_stderr": dict(multiline=True, mouse_support=True, history=InMemoryHistory(), converter=c.MultiLine), "expected_rc": dict(validator=v.Int(), converter=c.Int, history=InMemoryHistory()), "schema": dict(edit='.yaml', validator=v.JSON, history=InMemoryHistory(), converter=c.Yaml), "system_kwargs": dict(edit='.yaml', validator=v.JSON, history=InMemoryHistory(), converter=c.Yaml), "pre_process": dict(edit='.py', history=InMemoryHistory(), converter=c.MultiLine), "post_process": dict(edit='.py', history=InMemoryHistory(), converter=c.MultiLine), "target": dict(completer=merge_completers([granule_completer, server_name_completer]), history=InMemoryHistory()), "parent_step_ids": dict(validator=v.List(','), converter=c.List(',')) } parser = ArgumentParserRaise(allow_abbrev=False, prog='') subparser = parser.add_subparsers(dest='cmd') preview_parser = subparser.add_parser('preview') subpreview_parser = preview_parser.add_subparsers(dest='subcmd') subpreview_parser.add_parser('action') set_parser = subparser.add_parser('set') set_parser.add_argument('parameter', help=', '.join(form.keys())) delete_parser = subparser.add_parser('delete') delete_parser.add_argument('parameter', help=', '.join(form.keys())) save_parser = subparser.add_parser('save') exit_parser = subparser.add_parser('exit')
def main(): completer = merge_completers([animal_completer, color_completer]) text = prompt('Give some animals: ', completer=completer, complete_while_typing=False) print('You said: %s' % text)
def get_completions(self, document: Document, complete_event: CompleteEvent) -> Iterable[Completion]: """ Get a list of completions for the given document """ text = document.text_before_cursor.lstrip() try: args = shlex.split(text) except ValueError: try: args = shlex.split(text + '"') except ValueError: args = shlex.split(text + "'") # We haven't finished typing the command. Use our word completer for # commands if text == "" or (len(args) == 1 and not text.endswith(" ")): yield from self.completer.get_completions(document, complete_event) return # Not in a known command, can't autocomplete if args[0] not in self.layers: return command = self.layers[args[0]] args = args[1:] next_completer = command[0] this_completer = command[0] positional = 0 # state = "options", completing options next # state = "arguments", completing arguments to options next state = "options" for arg in args: if state == "options": # Flag options if arg.startswith("-"): # Exact match, with a sub-completer if arg in command[2] and command[2][arg] is not None: # Completer for next argument next_completer = command[2][arg] state = "arguments" # Exact match, with no arguments elif arg in command[2]: # Command has no argument, next completer is options # completer next_completer = command[0] state = "options" this_completer = command[0] # Non-exact match else: next_completer = command[0] this_completer = command[0] state = "options" # Appears to be a positional argument, grab next positional # completer and increment positional count else: if positional < len(command[1]): this_completer = command[1][positional] next_completer = command[0] state = "options" positional += 1 else: this_completer = command[0] next_completer = command[0] state = "options" else: # Completing an argument to a option/switch. We can't verify # it's legitimacy, so we assume it's right, and reset to a # default state. state = "options" this_completer = next_completer next_completer = command[0] # We are completing the first argument. This could be # any option argument or the first positional argument. # We need to merge them. if not args and text.endswith(" ") and command[1]: completer = command[1][0] if isinstance(completer, tuple) and completer[0] == "choices": completer = WordCompleter(completer[1], WORD=True) next_completer = merge_completers([next_completer, completer]) if isinstance(this_completer, tuple) and this_completer[0] == "choices": this_completer = WordCompleter(this_completer[1], WORD=True) if isinstance(next_completer, tuple) and next_completer[0] == "choices": next_completer = WordCompleter(next_completer[1], WORD=True) if text.endswith(" ") and next_completer is not None: yield from next_completer.get_completions(document, complete_event) elif this_completer is not None: yield from this_completer.get_completions(document, complete_event)
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()
IfsqlCompleter = merge_completers([ WordCompleter( [ "select", "distinct", "all", "from", "collate", "asc", "desc", "order", "by", "limit", "offset", "where", "group", "having" "as", "not", "like", "glob", "regexp", "match", "escape", "isnull", "notnull", "not null", "not", "and", "or", "is", "in", "between", "case", "when", "then", "else", "end", "raise", "ignore", "rollback", "abort", "fail", "null", ], ignore_case=True, ), WordCompleter(database.fields(), ignore_case=True), ])
def __init__(self, verbose=False): try: if args.directory: os.chdir(args.directory) except: pass self.config = cfg.Config(verbose=verbose, colored=True) self.config.load() self.config.fallback = { "aliases": {}, "colored": True, "prompt": "<base>┏━━(</base><user>${USER}</user> <base>at</base> <user>${DOMAIN}</user><base>)━[</base><path>${PATH}</path><base>]━[</base><style fg='${green-yellow}'>${REPO}</style><base>]━[</base><style fg='yellow'>${TIME}</style><base>]\n┗━</base><pointer>${ROOT}</pointer> ", "style": { # Default style "": "", # Specific style "base": "#1a8cff", "pointer": "#ff4500", "path": "aqua", "user": "******", # Completer "completion-menu.completion": "bg:#000000 #ffffff", "completion-menu.completion.current": "bg:#00aaaa #000000", "scrollbar.background": "bg:#88aaaa", "scrollbar.button": "bg:#222222" }, "dialog_style": { "dialog": "bg:#88ff88", "dialog frame-label": "bg:#ffffff #000000", "dialog.body": "bg:#000000 #00ff00", "dialog shadow": "bg:#00aa00", } } self.config.colored = self.config["colored"] self.style = Style.from_dict(self.config["style"]) self.dialog_style = Style.from_dict(self.config["dialog_style"]) self.manager = manager self.file = None self.mode = None self.userInput = None if platform.system() == "Windows": self.histfile = os.environ["userprofile"] + \ r"\.voidhistory" # Rename this else: # Rename this ... alternative for linux or Unix based systems self.histfile = os.path.expanduser("~")+r"/.voidhistory" self.history = FileHistory(self.histfile) if not args.command: function_completer = NestedCompleter.from_nested_dict( dict.fromkeys(functions)) pth_completer = path_completer.PathCompleter(expanduser=True) environ_completer = env_completer.EnvCompleter( file_filter=filter) merged_completers = merge_completers( [function_completer, pth_completer, environ_completer]) self.completer = ThreadedCompleter(merged_completers) else: self.completer = None super().__init__(completer=self.completer, complete_while_typing=False, auto_suggest=AutoSuggestFromHistory(), search_ignore_case=True, refresh_interval=0, color_depth=ColorDepth.TRUE_COLOR, editing_mode=EditingMode.VI, style=self.style, history=self.history)
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 PythonCompleter( self.get_globals, self.get_locals, lambda: self.enable_dictionary_completion, ) self._completer = HidePrivateCompleter( # If fuzzy is enabled, first do fuzzy completion, but always add # the non-fuzzy completions, if somehow the fuzzy completer didn't # find them. (Due to the way the cursor position is moved in the # fuzzy completer, some completions will not always be found by the # fuzzy completer, but will be found with the normal completer.) merge_completers( [ ConditionalCompleter( FuzzyCompleter( DynamicCompleter(lambda: self.completer)), Condition(lambda: self.enable_fuzzy_completion), ), DynamicCompleter(lambda: self.completer), ], deduplicate=True, ), lambda: self.complete_private_attributes, ) self._validator = _validator or PythonValidator( self.get_compiler_flags) self._lexer = PtpythonLexer(_lexer) 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 # Also eval-based completion. self.complete_private_attributes: CompletePrivateAttributes = ( CompletePrivateAttributes.ALWAYS) self.swap_light_and_dark: bool = False self.highlight_matching_parenthesis: bool = False self.show_sidebar: bool = False # Currently show the sidebar. # Pager. self.enable_output_formatting: bool = False self.enable_pager: bool = False self.show_locals: bool = True # 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.) self.insert_blank_line_after_input: bool = False # (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[Signature] = [] # 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 # Get into Vi navigation mode at startup self.vi_start_in_navigation_mode: bool = False # Preserve last used Vi input mode between main loop iterations self.vi_keep_last_used_mode: 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
action_list ], 'create': [{'argument': 'name'}, {'argument': 'action_type', 'choices': [at.name for at in ActionType if at.name != 'NATIVE']}, {'argument': '--prompt', 'action': "store_true", 'help': 'prompts for every action parameter to be set by user'}, action_create], 'copy': [{'argument': 'action_template_id', 'completer': action_completer}, action_copy], 'load': [{'argument': 'file', 'type': argparse.FileType('r')}, action_load], }, 'cmd': [{'argument': 'command', 'nargs': '*'}, {'argument': '--shell', 'action': 'store_true'}, {'argument': '--target', 'action': ExtendAction, 'nargs': "+", 'completer': merge_completers([server_completer, granule_completer])}, {'argument': '--timeout', 'type': int, 'help': 'timeout in seconds to wait for command to terminate'}, {'argument': '--input'}, cmd], "env": { "list": [env_list], "get": [{'argument': 'key', 'completer': DshellWordCompleter(environ._environ.keys())}, env_get], "set": [{'argument': 'key', 'completer': DshellWordCompleter(environ._environ.keys())}, {'argument': 'value', 'nargs': '*'}, env_set]}, 'exec': { 'list': [{'argument': '--orch', 'completer': orch_completer}, {'argument': '--id', 'dest': 'execution_id'}, {'argument': '--server', 'completer': server_completer}, {'argument': '--last', 'metavar': 'N', 'type': int, 'help': "shows last N orchestrations"},
cfg["packet"].dest, cfg["packet"].dport, ) return text cmd_completer = WordCompleter([ 'load-dir', 'load-iptables', 'load-ipaddrs', 'load-iproutes', 'load-ipsets', 'set-source', 'set-dest', 'set-sport', 'set-dport', 'run-incomming-packet', 'run-localgen-packet', 'exit', ], ignore_case=True) session = PromptSession() if __name__ == '__main__': init(autoreset=True) while True: input = session.prompt('> ', bottom_toolbar=bottom_statusbar, completer=merge_completers([PathCompleter(min_input_len=1), cmd_completer])) if not input.split(): continue if input.split()[0] == "exit": break if input.split()[0] == "load-localhost": print("not implemented") continue if input.split()[0] == "load-dir": try: cfg["iptables"] = ParseIPTables(input.split()[1] + r"/iptables.txt") cfg["ipaddrs"], cfg["non_local_ip"] = ParseIPAddrs(input.split()[1] + r"/ipaddrs.txt") cfg["iproutes"] = ParseIPRoutes(input.split()[1] + r"/iproutes.txt") cfg["ipsets"] = ParseIPSets(input.split()[1] + r"/ipsets.txt") except Exception as e: print("load config failed. " + str(e))
def make_completer(engine, config): return merge_completers([ WordCompleter(magic.command_list(config), WORD=True), GhciCompleter(engine), WordCompleter(keywords)])