def _path_completer(self): if self._path_completer_cache is None: self._path_completer_cache = GrammarCompleter( self._path_completer_grammar, {'var1': PathCompleter(expanduser=True), 'var2': PathCompleter(expanduser=True),}) return self._path_completer_cache
def __init__(self): namespace = q(r'\d') res = q('.Q.res') dot_q = q('1_key .q') self.path_completer = PathCompleter() self.words_info = [(list(res), 'k'), (list(dot_q), 'q'), (list(q.key(namespace)), str(namespace))]
def create_completer(get_globals, get_locals, magics_manager, alias_manager): g = create_ipython_grammar() return GrammarCompleter( g, { 'python': PythonCompleter(get_globals, get_locals), 'magic': MagicsCompleter(magics_manager), 'alias_name': AliasCompleter(alias_manager), 'pdb_arg': WordCompleter(['on', 'off'], ignore_case=True), 'autocall_arg': WordCompleter(['0', '1', '2'], ignore_case=True), 'py_filename': PathCompleter(only_directories=False, file_filter=lambda name: name.endswith('.py')), 'filename': PathCompleter(only_directories=False), 'directory': PathCompleter(only_directories=True), 'system': SystemCompleter(), })
def _create_path_completer(self): def unwrapper(text): return re.sub(r'\\(.)', r'\1', text) def single_quoted_wrapper(text): return text.replace('\\', '\\\\').replace("'", "\\'") def double_quoted_wrapper(text): return text.replace('\\', '\\\\').replace('"', '\\"') grammar = r""" # Text before the current string. ( [^'"#] | # Not quoted characters. ''' ([^']|'[^']|''[^']|\\.)* ''' | # Inside single quoted triple strings "" " ([^"]|"[^"]|""[^"]|\\.)* "" " | # Inside double quoted triple strings \#[^\n]*(\n|$) | # Comment. "(?!"") ([^"\\]|\\.)*" | # Inside double quoted strings. '(?!'') ([^'\\]|\\.)*' # Inside single quoted strings. # Warning: The negative lookahead in the above two # statements is important. If we drop that, # then the regex will try to interpret every # triple quoted string also as a single quoted # string, making this exponentially expensive to # execute! )* # The current string that we're completing. ( ' (?P<var1>([^\n'\\]|\\.)*) | # Inside a single quoted string. " (?P<var2>([^\n"\\]|\\.)*) # Inside a double quoted string. ) """ g = compile_grammar(grammar, escape_funcs={ 'var1': single_quoted_wrapper, 'var2': double_quoted_wrapper, }, unescape_funcs={ 'var1': unwrapper, 'var2': unwrapper, }) return g, GrammarCompleter( g, { 'var1': PathCompleter(expanduser=True), 'var2': PathCompleter(expanduser=True), })
class QCompleter(Completer): """Completer for the q language""" def __init__(self): namespace = q(r'\d') res = q('.Q.res') dot_q = q('1_key .q') self.path_completer = PathCompleter() self.words_info = [(list(res), 'k'), (list(dot_q), 'q'), (list(q.key(namespace)), str(namespace))] def get_completions(self, document, complete_event): """Yield completions""" # Detect a file handle m = HSYM_RE.match(document.text_before_cursor) if m: text = m.group(1) doc = Document(text, len(text)) for c in self.path_completer.get_completions(doc, complete_event): yield c else: # Get word/text before cursor. word_before_cursor = document.get_word_before_cursor(False) for words, meta in self.words_info: for a in words: if a.startswith(word_before_cursor): yield Completion(a, -len(word_before_cursor), display_meta=meta)
def prompt_spec_exec_dict(run_dict: dict) -> dict: """ Prompt for the config of the spec exec runner. :param run_dict: run config dict (without the runner part) :return: runner config """ runner_dict = {} runner_dict["file"] = default_prompt("SPEC like result file to use: ", validator=TypeValidator(FileName()), completer=PathCompleter()) runner_dict["base_path"] = prompt("Property base path: ") runner_dict["path_regexp"] = prompt("Regexp matching the property path for each measured property: ", validator=NonEmptyValidator()) def get(sub_path: str = ""): # just a mock """ Get the value of the property with the given path. :param sub_path: given path relative to the base path :return: value of the property """ print("The python code is entered via a multiline input. ") print("Press [Meta+Enter] or [Esc] followed by [Enter] to accept input.") print("You can click with the mouse in order to select text.") print("Use the get(sub_path: str) -> str function to obtain a properties value.") locs = locals() runner_dict["code"] = prompt_python("The python is executed for each measured property: \n", lambda: {}, lambda: {"get": locs["get"]}) return runner_dict
def prompt_dir(msg: str) -> str: """ Prompt a directory path. Default is ".". :param msg: shown message :return: user input """ return default_prompt(msg, default=".", validator=TypeValidator(DirName()), completer=PathCompleter(only_directories=True))
def __init__(self, vi_mode=False, style=None, search_text=None, titlebar_tokens=None): assert isinstance(vi_mode, bool) assert style is None or isinstance(style, Style) self.sources = [] self.current_source = 0 # Index in `self.sources`. self.vi_mode = vi_mode self.highlight_search = True self.in_colon_mode = False self.message = None self.displaying_help = False self.search_text = search_text self.display_titlebar = bool(titlebar_tokens) self.titlebar_tokens = titlebar_tokens or [] # When this is True, always make sure that the cursor goes to the # bottom of the visible content. This is similar to 'tail -f'. self.forward_forever = False # Status information for all sources. Source -> _SourceInfo. # (Remember this info as long as the Source object exists.) self.source_info = weakref.WeakKeyDictionary() # Create prompt_toolkit stuff. self.buffers = BufferMapping({}) def open_file(cli, buff): # Open file. self.open_file(buff.text) # Focus main buffer again. self.buffers.focus(cli, self.source_info[self.source].buffer_name) buff.reset() self.buffers['EXAMINE'] = Buffer( # Buffer for the 'Examine:' input. completer=PathCompleter(expanduser=True), accept_action=AcceptAction(open_file)) self.layout = Layout(self) registry = create_key_bindings(self) self.application = Application(layout=self.layout.container, buffers=self.buffers, key_bindings_registry=registry, style=style or create_style(), mouse_support=True, on_render=self._on_render, use_alternate_screen=True, on_initialize=self._on_cli_initialize) self.cli = None self.eventloop = None
def _prompt(message, default='', path=False, list_=None, required=True, validate=None, allow_invalid=False, password=False, help=None): def _get_prompt_tokens(cli): rv = [ (Token.PROMPT, message), (Token.COLON, ': '), ] if first and help: rv.insert(0, (Token.HELP, wrap_text(help) + '\n')) return rv completer = None if path: completer = PathCompleter(only_directories=True, expanduser=True) elif list_: completer = WordCompleter( sorted(list_), ignore_case=True, sentence=True, meta_dict=(list_ if isinstance(list_, dict) else None)) if validate is None: validate = list_.__contains__ first = True while True: try: rv = prompt(get_prompt_tokens=_get_prompt_tokens, default=default, is_password=password, completer=completer, lexer=SimpleLexer(Token.INPUT), style=PROMPT_TOOLKIT_STYLE) except (EOFError, KeyboardInterrupt): sys.exit(1) # pasting a multiline string works even with multiline disabled :( rv = rv.replace('\n', ' ').strip() if not rv: if not required: break else: if path: rv = os.path.abspath(os.path.expanduser(rv)) if validate is None or validate(rv): break if allow_invalid and _confirm('Keep this value anyway?'): break default = rv first = False return rv
def _create_path_completer(self): def unwrapper(text): return re.sub(r'\\(.)', r'\1', text) def single_quoted_wrapper(text): return text.replace('\\', '\\\\').replace("'", "\\'") def double_quoted_wrapper(text): return text.replace('\\', '\\\\').replace('"', '\\"') grammar = r""" # Text before the current string. ( [^'"#] | # Not quoted characters. '''.*''' | # Inside single quoted triple strings "" ".*"" " | # Inside double quoted triple strings \#[^\n]* | # Comment. "([^"\\]|\\.)*" | # Inside double quoted strings. '([^'\\]|\\.)*' # Inside single quoted strings. )* # The current string that we're completing. ( ' (?P<var1>([^\n'\\]|\\.)*) | # Inside a single quoted string. " (?P<var2>([^\n"\\]|\\.)*) # Inside a double quoted string. ) """ g = compile_grammar(grammar, escape_funcs={ 'var1': single_quoted_wrapper, 'var2': double_quoted_wrapper, }, unescape_funcs={ 'var1': unwrapper, 'var2': unwrapper, }) return g, GrammarCompleter(g, { 'var1': PathCompleter(), 'var2': PathCompleter(), })
def coroutine(): global current_path open_dialog = TextInputDialog(title='Open file', label_text='Enter the path of a file:', completer=PathCompleter()) path = yield From(show_dialog_as_float(open_dialog)) current_path = path if path is not None: try: with open(path, 'rb') as f: text_field.text = f.read().decode('utf-8', errors='ignore') except IOError as e: show_message('Error', '{}'.format(e))
def askDir(msg, default=''): from prompt_toolkit import prompt try: # prompt_toolkit 1 from prompt_toolkit.contrib.completers import PathCompleter except Exception: # prompt_toolkit 2 from prompt_toolkit.completion import PathCompleter from ..utils import mkdirs is_cygwin = isCygwin() completer = PathCompleter(only_directories=True, expanduser=True) msg = six.u(msg) + u' ' default = six.u(default) path = None while not path: # prompt_toolkit doesn't work in cygwin terminal or in PyCharm debugger # path = askString(msg, default) if is_cygwin else prompt(msg, default=default, completer=completer) if is_cygwin: path = askString(msg, default) else: try: path = prompt(msg, default=default, completer=completer) except AssertionError: # stdout.isatty() fails in PyCharm debugger path = askString(msg, default) path = expandTilde(path) if path and not os.path.isdir(path): if os.path.lexists(path): print('Path %s exists, but is not a directory. Try again.' % path) path = '' continue create = askYesNo("Path %s does not exist. Create it" % path, default='y') if not create: path = '' continue mkdirs(path) print('Created %s' % path) return path
def prompt_config(name: str, prompt_dict_func: t.Callable[[], dict]): """ Prompt for the whole config file. :param name: description of the config (i.e. "run config") :param prompt_dict_func: function to get a single config dict """ blocks = [] file = prompt("YAML file to store the {name} in: ".format(name=name), validator=TypeValidator(ValidYamlFileName(allow_non_existent=True)), completer=PathCompleter()) fd = None # type: io.IOBase if os.path.exists(file): actions = { "append": "Append to the file", "overwrite": "Overwrite the file" } res = prompt("The file already exists. What should be done? ", completer=WordCompleter(sorted(list(actions.keys())), meta_dict=actions, ignore_case=True), validator=WordValidator(list(actions.keys()) + ["a", "o"], error_msg="Not a valid action")) if res.startswith("a"): fd = open(file, "a+") elif res.startswith("o"): fd = open(file, "w+") else: fd = open(file, "w+") blocks.append(prompt_dict_func()) def store_in_file(): #print(blocks) yaml.dump(blocks, fd) fd.flush() fd.close() while prompt_yesno("Add another {name}? ".format(name=name)): try: blocks.append(prompt_dict_func()) except KeyboardInterrupt: store_in_file() return except BaseException as ex: store_in_file() raise ex store_in_file()
def get_path_matches(self, _, word_before_cursor): completer = PathCompleter(expanduser=True) document = Document(text=word_before_cursor, cursor_position=len(word_before_cursor)) for c in completer.get_completions(document, None): yield Match(completion=c, priority=(0,))
def get_path(): path = prompt('> enter path: ', completer=PathCompleter(only_directories=True, expanduser=True)) return (os.path.expanduser(path), ), {}
# !/usr/bin/env python # -*- coding:utf-8 -*- from __future__ import unicode_literals __author__ = 'bit4' __github__ = 'https://github.com/bit4woo' """ Autocompletion example that displays the autocompletions like readline does by binding a custom handler to the Tab key. """ from prompt_toolkit.shortcuts import prompt from prompt_toolkit.shortcuts import confirm from prompt_toolkit.contrib.completers import WordCompleter, PathCompleter import os animal_completer = PathCompleter("C:\\") def main(): text = prompt('Give some animals: ', completer=animal_completer) print('You said: %s' % text) if __name__ == '__main__': answer = confirm('Should we do that? (Y/n) ') print('You said: %s' % answer)
def get_path_matches(self, _, word_before_cursor): completer = PathCompleter(expanduser=True) document = Document(text=word_before_cursor, cursor_position=len(word_before_cursor)) for c in completer.get_completions(document, None): yield Match(completion=c, priority=(0, ))
def interactive(): print color.G + "\n\nWelcome to interactive mode!\n\n" task_home_dir = os.path.join(os.path.dirname(__file__), "task") while True: # print already existed task tasks = os.listdir(task_home_dir) for task in tasks: if os.path.isfile(task): tasks.remove(task) print "{0}[{1}]{2} tasks existed:".format(color.R, len(tasks), color.G) for item in tasks: print item print( color.Y + "\n\n" "*.Input a existed task name to operate it or Input a new task name to create.\n" "*.Input q to query vuln from wvs.\n" "*.Input x to exit Ashe.\n" "\n" + color.W) task_completer = WordCompleter(tasks, ignore_case=True) task_name = prompt(u"==>", completer=task_completer) if task_name.lower() == "q": #QueryFromWVS() pass elif task_name.lower() in ['x', 'back']: break elif task_name == "": continue else: task_dir = os.path.join(task_home_dir, task_name) if os.path.isdir(task_dir): choice = prompt( u"the task already exist, operate this task? (Y/n)", ) if choice.lower() not in ["y", "yes", ""]: continue else: os.mkdir(task_dir) print "task {0} created, chose what to do:".format(task_name) urls_file = os.path.join(task_dir, "{0}_urls_by_ashe.txt".format(task_name)) urls_scanned_file = os.path.join( task_dir, "{0}_urls_scanned_by_ashe.txt".format(task_name)) while True: index = taskDealIndex.format(task_name) choice = prompt(unicode(index)) if choice == "1": delete = prompt(u"Are you sure to DELETE this task?(y/N)") if delete.lower() in ["y", "yes"]: shutil.rmtree(task_dir) break else: continue elif choice == "2": path_completer = PathCompleter() xmlfile = prompt( u"parse xml, please input the xml file==>", completer=path_completer, history=FileHistory('history.txt'), auto_suggest=AutoSuggestFromHistory(), ) xmlfile = xmlfile.strip() if os.path.isfile(xmlfile): des_xml_file = os.path.join(task_dir, os.path.basename(xmlfile)) if os.path.abspath(xmlfile) == os.path.abspath( des_xml_file): # same file pass elif os.path.exists(des_xml_file): copy_choice = prompt( u"The file already exist,Overwirte or keep Two(O/t)?" ) if copy_choice.lower() in ["", "o"]: shutil.copyfile(xmlfile, des_xml_file) # overwrite elif copy_choice.lower() == "t": des_xml_file = os.path.join( task_dir, os.path.basename(xmlfile).split(".")[0] + "_1" + os.path.basename(xmlfile).split(".")[1]) shutil.copy(xmlfile, des_xml_file) else: continue else: shutil.copy(xmlfile, des_xml_file) url_list = GetHttp(xmlfile) print(url_list) fp = open(urls_file, "a+") if len(fp.readlines()) == 0: pass else: fp.write("\n") fp.writelines("\n".join(url_list)) fp.close() else: print "File do not exist!" continue elif choice == "3": IP_domain_file = prompt( u"Input the file that contains domain and IP relationship(Teemo Result File)\n==>" ) IP_domain_file = IP_domain_file.strip() if os.path.isfile(IP_domain_file): des_IP_Domain_file = os.path.join( task_dir, "Teemo-" + os.path.basename(IP_domain_file)) if os.path.abspath(IP_domain_file) == os.path.abspath( des_IP_Domain_file): # same file pass elif os.path.exists(des_IP_Domain_file): shutil.copyfile(IP_domain_file, des_IP_Domain_file) # overwrite else: shutil.copy(IP_domain_file, des_IP_Domain_file) IP2domain(urls_file, des_IP_Domain_file) else: print "File do not exist!" continue elif choice == "4": if os.path.isfile(urls_file): fp = open(urls_file, "r") urls = fp.readlines() fp.close() end_index = -1 if SCANNER.lower() == "wvs11": end_index = AddScans(urls) elif SCANNER.lower() == "wvs10": end_index = AddToWVS(urls) print "{0} urls added".format(end_index + 1) if end_index >= 0: urls_left = urls[end_index + 1:-1] urls_scanned = urls[0:end_index] fp = open(urls_file, "w") fp.writelines(urls_left) fp.close() fp = open(urls_scanned_file, "a") fp.writelines(urls_scanned) fp.write("____above urls added to scan at {0}______\n". format(datetime.datetime.now().strftime( "%m/%d/%Y %H%M"))) fp.close() break else: print "{0} not found!".format(urls_file) elif choice.lower() in ["5", 'back', 'exit']: break else: continue