def get_completer(): def get_paths(): return [build_context.config.work_dir] return NestedCompleter.from_nested_dict({ "help": None, "glob": { "build": None, "host": None }, "exit": None, "ls": PathCompleter(get_paths=get_paths), "edit": { "file": PathCompleter(get_paths=get_paths), "script": None, "recipe": None, }, "build": None, "patch": { "show": None, "save": None }, })
def test_pathcompleter_completes_in_current_directory(): completer = PathCompleter() doc_text = "" doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) assert len(completions) > 0
def test_pathcompleter_completes_in_current_directory(): completer = PathCompleter() doc_text = '' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) assert len(completions) > 0
def create_completer( get_globals, get_locals, magics_manager, alias_manager, get_enable_dictionary_completion, ): g = create_ipython_grammar() return GrammarCompleter( g, { "python": PythonCompleter(get_globals, get_locals, get_enable_dictionary_completion), "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_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 test_pathcompleter_does_not_expanduser_by_default(): completer = PathCompleter() doc_text = '~' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) assert [] == completions
def test_pathcompleter_can_expanduser(): completer = PathCompleter(expanduser=True) doc_text = '~' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) assert len(completions) > 0
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 test_pathcompleter_respects_completions_under_min_input_len(): # setup: create a test dir with 10 files test_dir = tempfile.mkdtemp() write_test_files(test_dir) # min len:1 and no text with chdir(test_dir): completer = PathCompleter(min_input_len=1) doc_text = '' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) assert [] == completions # min len:1 and text of len 1 with chdir(test_dir): completer = PathCompleter(min_input_len=1) doc_text = '1' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) result = [c.text for c in completions] assert [''] == result # min len:0 and text of len 2 with chdir(test_dir): completer = PathCompleter(min_input_len=0) doc_text = '1' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) result = [c.text for c in completions] assert [''] == result # create 10 files with a 2 char long name for i in range(10): with open(os.path.join(test_dir, str(i) * 2), 'wb') as out: out.write(b'') # min len:1 and text of len 1 with chdir(test_dir): completer = PathCompleter(min_input_len=1) doc_text = '2' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) result = sorted(c.text for c in completions) assert ['', '2'] == result # min len:2 and text of len 1 with chdir(test_dir): completer = PathCompleter(min_input_len=2) doc_text = '2' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) assert [] == completions # cleanup shutil.rmtree(test_dir)
def test_pathcompleter_does_not_expanduser_by_default(): completer = PathCompleter() doc_text = "~" doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) assert [] == completions
def test_pathcompleter_completes_directories_with_only_directories(): # setup: create a test dir with 10 files test_dir = tempfile.mkdtemp() write_test_files(test_dir) # create a sub directory there os.mkdir(os.path.join(test_dir, 'subdir')) if not test_dir.endswith(os.path.sep): test_dir += os.path.sep with chdir(test_dir): completer = PathCompleter(only_directories=True) doc_text = '' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) result = [c.text for c in completions] assert ['subdir'] == result # check that there is no completion when passing a file with chdir(test_dir): completer = PathCompleter(only_directories=True) doc_text = '1' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) assert [] == completions # cleanup shutil.rmtree(test_dir)
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 test_pathcompleter_can_expanduser(monkeypatch): monkeypatch.setenv('HOME', '/tmp') completer = PathCompleter(expanduser=True) doc_text = "~" doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) assert len(completions) > 0
def get_path_matches(self, _, word_before_cursor): # pylint: disable=no-self-use # function cannot be static since it has to be a callable for get_completions 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 __init__(self): self.path_completer = PathCompleter( file_filter=lambda s: os.path.isdir(s) or s.endswith('.lua')) self.word_completer = WordCompleter( words=self.CROW_COMMANDS.keys(), ignore_case=True, meta_dict=self.CROW_COMMANDS, )
def __init__(self, hummingbot_application): super(HummingbotCompleter, self).__init__() self.hummingbot_application = hummingbot_application # static completers self._path_completer = PathCompleter(get_paths=lambda: [f"./{CONF_FILE_PATH}"], file_filter=lambda fname: fname.endswith(".yml")) self._command_completer = WordCompleter(self.parser.commands, ignore_case=True) self._exchange_completer = WordCompleter(EXCHANGES, ignore_case=True) self._strategy_completer = WordCompleter(STRATEGIES, ignore_case=True)
def _path_completer(self) -> GrammarCompleter: 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, hummingbot_application): super(HummingbotCompleter, self).__init__() self.hummingbot_application = hummingbot_application self._symbols: Dict[str, List[str]] = {} # static completers self._path_completer = PathCompleter() self._command_completer = WordCompleter(self.parser.commands, ignore_case=True) self._exchange_completer = WordCompleter(EXCHANGES, ignore_case=True) self._strategy_completer = WordCompleter(STRATEGIES, ignore_case=True) asyncio.ensure_future(self._fetch_symbols())
def arg_completer(arg: ArgInfo) -> Optional[Completer]: if arg.possible_values: meta = {a: arg.help_text for a in arg.possible_values } if arg.help_text is not None else None return FuzzyWordCompleter(arg.possible_values, meta_dict=meta) elif arg.value_hint == "file": return PathCompleter() elif arg.value_hint == "kind": return KindCompleter(kinds, props) elif arg.value_hint == "property": return PropertyCompleter(kinds, props) elif arg.value_hint == "property_list_plain": return PropertyListCompleter(kinds, props, with_as=False) elif arg.value_hint == "property_list_with_as": return PropertyListCompleter(kinds, props, with_as=True) elif arg.value_hint == "command": meta = {cmd.name: "command" for cmd in cmds} return FuzzyWordCompleter([cmd.name for cmd in cmds], meta_dict=meta) elif arg.value_hint == "search": return SearchCompleter(kinds, props) elif arg.value_hint == "aggregate": return AggregateCompleter(kinds, props) elif arg.help_text: return HintCompleter("<value>", arg.help_text) else: return HintCompleter("<value>")
def edit(file_path, db_path): """Create and edit piece information""" if not file_path: try: with open(PATHSAVE, "r") as savepath: file_path = Path(savepath.read()) except FileNotFoundError: file_path = prompt( "No path specified or saved. Please enter the path " "to the config file. ", completer=PathCompleter()) try: piece = yaml_interface.read_config(Path(file_path)) print('loaded piece') print(piece) except (ValueError, FileNotFoundError, AttributeError): piece = None db = db_interface.init_db(db_path) tables = db_interface.explore_db(db) if "composers" not in tables or "instruments" not in tables: bootstrap = prompt( "Lilyskel supports a small database to help with " "commonly used items (such as instruments and " "composers). You do not appear to have one. " "Would you like to copy the included one? ", default='Y', validator=YNValidator()) if bootstrap.lower()[0] == 'y': db_interface.bootstrap_db(db_path) edit_prompt(piece, Path(file_path), db, PATHSAVE)
def __init__(self, completions, meta_dict, project_root): self.words = WordCompleter(completions, meta_dict=meta_dict, WORD=True, ignore_case=True) # TODO Rewrite using the one in prompt-toolkit/completion/filesystem.py as ref, but include '/' at the end of dir completions self.paths = PathCompleter(get_paths=(lambda: [str(project_root)]))
async def coroutine(): global current_file global isort_config global black_config open_dialog = TextInputDialog( title="Open file", label_text="Enter the path of a file:", completer=PathCompleter(), ) filename = await show_dialog_as_float(open_dialog) if filename is not None: current_file = Path(filename).resolve() isort_config = isort.Config(settings_path=current_file.parent) black_config_file = black.find_pyproject_toml( (str(current_file), )) if black_config_file: black_config = black.parse_pyproject_toml(black_config_file) else: black_config = {} try: with open(current_file, "r", encoding="utf8") as new_file_conent: code.buffer.text = new_file_conent.read() open_file_frame.title = current_file.name feedback(f"Successfully opened {current_file}") except IOError as error: feedback(f"Error: {error}")
def chose_install_dir(json_file): validator = Validator.from_callable( lambda x: os.path.isdir(x) or x == '', error_message="Not a directory!", move_cursor_to_end=True, ) path_completer = PathCompleter(only_directories=True) default_dir = json_file['install_dir'] or './' question = "\nPath to install datasets [empty to default " + \ default_dir + "] " install_dir = prompt(question, validator=validator, completer=path_completer) if not install_dir: if not os.path.isdir(default_dir): os.mkdir(default_dir) install_dir = default_dir if install_dir.endswith('/'): install_dir = install_dir[:-1] json_file['install_dir'] = install_dir return install_dir
async def coroutine(): global current_file global isort_config global black_config save_dialog = TextInputDialog( title="Save file", label_text="Enter the path of a file:", completer=PathCompleter(), ) filename = await show_dialog_as_float(save_dialog) if filename is not None: current_file = Path(filename).resolve() isort_config = isort.Config(settings_path=current_file.parent) black_config_file = black.find_pyproject_toml( (str(current_file), )) if black_config_file: black_config = black.parse_pyproject_toml(black_config_file) else: black_config = {} if not current_file.suffixes and not current_file.exists(): current_file = current_file.with_suffix(".py") open_file_frame.title = current_file.name save_file()
def configure(config: Config): bastion = InstanceHelper().select_instance(message='Choose bastion host', include_none=True) bastion_user = questionary.text(message="Bastion host user", default=config.bastion_user or "").ask() bastion_port = questionary.text(message="Bastion host port", default=config.bastion_port or "22").ask() instance_user = questionary.text(message="Default instance user", default=config.instance_user or "").ask() key = Path( questionary.text( message="Private SSH Key Path", default=str(config.key) if config.key is not None else "", validate=KeyValidator, completer=PathCompleter(expanduser=True)).ask()) # Save all of the configuration options config.bastion = bastion config.bastion_port = bastion_port config.bastion_user = bastion_user config.instance_user = instance_user config.key = key
def input_path(self): msg, default, validator = self.__get_commond_attr() path_completer = PathCompleter(only_directories=True, min_input_len=1) return prompt(msg, completer=path_completer, default=default, validator=validator, key_bindings=self.bindings)
def ask_dir(): Path = PathCompleter(only_directories=True) while True: with quittable(): path = prompt('> ', completer=Path) if os.path.isdir(path): return path print("Not a valid directory")
def _run (): with patch_stdout(): application = input_dialog( title = title, text = text, completer = PathCompleter() ) with application.input.raw_mode(): application.input.read_keys() application.layout.current_control.buffer.insert_text(default_value or "") return application.run_async()
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 _prompt(message, default='', path=False, list_=None, required=True, validate=None, allow_invalid=False, password=False, help=None): def _get_prompt_tokens(): rv = [ ('class:prompt', message), ('class:colon', ': '), ] if first and help: rv.insert(0, ('class: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(), default=default, is_password=password, completer=completer, 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_cmd_buffer(self, command): completer = PathCompleter() # if command == 'open' or command == 'inspect': # completer=PathCompleter() # else: # completer=None accept_handler = getattr(self, 'do_' + command) return Buffer(completer=completer, name='cmd_buffer_' + command, accept_handler=accept_handler, multiline=False)
def create_command_completer(editor): commands = [c + ' ' for c in get_commands()] return GrammarCompleter(COMMAND_GRAMMAR, { 'command': WordCompleter(commands), 'location': PathCompleter(expanduser=True), 'set_option': WordCompleter(sorted(SET_COMMANDS)), 'buffer_name': BufferNameCompleter(editor), 'colorscheme': ColorSchemeCompleter(editor), 'shell_command': SystemCompleter(), })
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 _make_directory_completer(self): """ Private method that creates a completer for a field with ``data_type`` of "dir". Returns ------- completer : prompt_toolkit.completion.base.Completer A ``Completer`` instance that suggests directory names as potential completions for user input. """ return PathCompleter(expanduser=False, only_directories=True)
def test_pathcompleter_completes_files_in_current_directory(): # setup: create a test dir with 10 files test_dir = tempfile.mkdtemp() write_test_files(test_dir) expected = sorted([str(i) for i in range(10)]) if not test_dir.endswith(os.path.sep): test_dir += os.path.sep with chdir(test_dir): completer = PathCompleter() # this should complete on the cwd doc_text = '' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) result = sorted(c.text for c in completions) assert expected == result # cleanup shutil.rmtree(test_dir)
def test_pathcompleter_can_apply_file_filter(): # setup: create a test dir with 10 files test_dir = tempfile.mkdtemp() write_test_files(test_dir) # add a .csv file with open(os.path.join(test_dir, 'my.csv'), 'wb') as out: out.write(b'') file_filter = lambda f: f and f.endswith('.csv') with chdir(test_dir): completer = PathCompleter(file_filter=file_filter) doc_text = '' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) result = [c.text for c in completions] assert ['my.csv'] == result # cleanup shutil.rmtree(test_dir)
def test_pathcompleter_completes_files_in_absolute_directory(): # setup: create a test dir with 10 files test_dir = tempfile.mkdtemp() write_test_files(test_dir) expected = sorted([str(i) for i in range(10)]) test_dir = os.path.abspath(test_dir) if not test_dir.endswith(os.path.sep): test_dir += os.path.sep completer = PathCompleter() # force unicode doc_text = text_type(test_dir) doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) result = sorted([c.text for c in completions]) assert expected == result # cleanup shutil.rmtree(test_dir)
def test_pathcompleter_get_paths_constrains_path(): # setup: create a test dir with 10 files test_dir = tempfile.mkdtemp() write_test_files(test_dir) # add a subdir with 10 other files with different names subdir = os.path.join(test_dir, 'subdir') os.mkdir(subdir) write_test_files(subdir, 'abcdefghij') get_paths = lambda: ['subdir'] with chdir(test_dir): completer = PathCompleter(get_paths=get_paths) doc_text = '' doc = Document(doc_text, len(doc_text)) event = CompleteEvent() completions = list(completer.get_completions(doc, event)) result = [c.text for c in completions] expected = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] assert expected == result # cleanup shutil.rmtree(test_dir)
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,))