def main(): layout = Layout(left_margin=LeftMarginWithLineNumbers(), before_input=DefaultPrompt(text='Before input >> '), after_input=Prompt(' << after input'), top_toolbars=[ TextToolbar('This is a top toolbar', token=Token.TopToolbar1), TextToolbar('This is another top toolbar', token=Token.TopToolbar2), ], bottom_toolbars=[ ArgToolbar(), SearchToolbar(), CompletionsToolbar(), TextToolbar('This is a bottom toolbar', token=Token.BottomToolbar1), TextToolbar('This is another bottom toolbar', token=Token.BottomToolbar2), ], show_tildes=True, menus=[CompletionsMenu()]) cli = CommandLineInterface(layout=layout, style=TestStyle, line=Line(is_multiline=True, completer=TestCompleter())) code_obj = cli.read_input(initial_value=lipsum) print('You said: ' + code_obj.text)
def main(): cli = CommandLineInterface(layout=layout, style=TestStyle, line=Line(validator=EmailValidator())) document = cli.read_input() print('You said: ' + document.text)
def create_cli(message='', multiline=False, is_password=False, vi_mode=False, lexer=None, enable_system_prompt=False, enable_open_in_editor=False, validator=None, completer=None, style=None, history=None, get_bottom_toolbar_tokens=None): # Create history instance. if history is None: history = History() # Load all key bindings. manager = KeyBindingManager(enable_vi_mode=vi_mode, enable_system_prompt=enable_system_prompt, enable_open_in_editor=enable_open_in_editor) # Create interface. return CommandLineInterface( layout=create_default_layout(message=message, lexer=lexer, is_password=is_password, reserve_space_for_menu=(completer is not None), get_bottom_toolbar_tokens=get_bottom_toolbar_tokens), buffer=Buffer( is_multiline=multiline, history=history, validator=validator, completer=completer, ), key_bindings_registry=manager.registry, style=style)
def _create_cli(self): """Create the prompt_toolkit's CommandLineInterface.""" history = FileHistory(os.path.expanduser('~/.haxornewshistory')) toolbar = Toolbar(lambda: self.paginate_comments) layout = create_default_layout( message=u'haxor> ', reserve_space_for_menu=8, get_bottom_toolbar_tokens=toolbar.handler, ) cli_buffer = Buffer( history=history, auto_suggest=AutoSuggestFromHistory(), enable_history_search=True, completer=self.completer, complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT) self.key_manager = self._create_key_manager() style_factory = StyleFactory(self.theme) application = Application( mouse_support=False, style=style_factory.style, layout=layout, buffer=cli_buffer, key_bindings_registry=self.key_manager.manager.registry, on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ignore_case=True) eventloop = create_eventloop() self.cli = CommandLineInterface( application=application, eventloop=eventloop)
def initialize(self): history = InMemoryHistory() toolbar_handler = create_toolbar_handler(self.get_long_options) layout = create_prompt_layout( get_prompt_tokens=self.get_prompt_tokens, lexer=create_lexer(), get_bottom_toolbar_tokens=toolbar_handler) buf = Buffer(history=history, completer=CrutchCompleter(self.renv), complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT) manager = get_key_manager(self.set_long_options, self.get_long_options) application = Application(style=style_factory(), layout=layout, buffer=buf, key_bindings_registry=manager.registry, on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ignore_case=True) eventloop = create_eventloop() self.cli = CommandLineInterface(application=application, eventloop=eventloop)
def run(self): labels = self.neo4j.get_labels() relationship_types = self.neo4j.get_relationship_types() properties = self.neo4j.get_property_keys() if self.filename: with open(self.filename, "rb") as f: queries = split_queries_on_semicolons(f.read()) for query in queries: print("> " + query) self.handle_query(query) print() return click.secho(" ______ __ __ ______ __ __ ", fg="red") click.secho("/\ ___\ /\ \_\ \ /\ ___\ /\ \ /\ \ ", fg="yellow") click.secho("\ \ \____ \ \____ \ \ \ \____ \ \ \____ \ \ \ ", fg="green") click.secho(" \ \_____\ \/\_____\ \ \_____\ \ \_____\ \ \_\ ", fg="blue") click.secho(" \/_____/ \/_____/ \/_____/ \/_____/ \/_/ ", fg="magenta") print("Cycli version: {}".format(__version__)) print("Neo4j version: {}".format(".".join(map(str, self.neo4j.neo4j_version)))) print("Bug reports: https://github.com/nicolewhite/cycli/issues\n") completer = CypherCompleter(labels, relationship_types, properties) layout = create_prompt_layout( lexer=CypherLexer, get_prompt_tokens=get_tokens, reserve_space_for_menu=8, ) buff = CypherBuffer( accept_action=AcceptAction.RETURN_DOCUMENT, history=FileHistory(filename=os.path.expanduser('~/.cycli_history')), completer=completer, complete_while_typing=True, ) application = Application( style=PygmentsStyle(CypherStyle), buffer=buff, layout=layout, on_exit=AbortAction.RAISE_EXCEPTION, key_bindings_registry=CypherBinder.registry ) cli = CommandLineInterface(application=application, eventloop=create_eventloop()) try: while True: document = cli.run() query = document.text self.handle_query(query) except UserWantsOut: print("Goodbye!") except Exception as e: print(e)
def main(args=sys.argv[1:]): parser, args = parseargs(args) if args.debug: log.setLevel(logging.DEBUG) loop = asyncio.get_event_loop() grbl = SerialGrbl(args.device, args.baudrate, loop) registry = load_key_bindings_for_prompt() history = InMemoryHistory() app_loop = create_asyncio_eventloop(loop=loop) app = create_prompt_application(message='> ', history=history, key_bindings_registry=registry) cli = CommandLineInterface(application=app, eventloop=app_loop) for key, func in key_to_func.items(): func = functools.partial(func, grbl=grbl, loop=loop) registry.add_binding(key, eager=True)(func) try: main_task = asyncio.ensure_future(main_coro(loop, grbl, cli)) return loop.run_until_complete(main_task) except (EOFError, KeyboardInterrupt): main_task.cancel() return 1 except serial.SerialException as error: log.fatal(error) return 1
def main(): eventloop = create_eventloop() cli = CommandLineInterface(layout=Window( BufferControl(input_processors=[ClockPrompt()])), eventloop=eventloop) done = [False] # Non local def on_read_start(): """ This function is called when we start reading at the input. (Actually the start of the read-input event loop.) """ # Following function should be run in the background. # We do it by using an executor thread from the `CommandLineInterface` # instance. def run(): # Send every second a redraw request. while not done[0]: time.sleep(1) cli.request_redraw() cli.eventloop.run_in_executor(run) def on_read_end(): done[0] = True cli.onReadInputStart += on_read_start cli.onReadInputEnd += on_read_end code_obj = cli.read_input() print('You said: %s' % code_obj.text) eventloop.close()
def run(): validate_osenvironment() print_banner() cli_buffer = OSBuffer() ltobj = OSLayout(multiwindow=False) application = Application(style=PygmentsStyle(OSStyle), layout=ltobj.layout, buffers=cli_buffer.buffers, on_exit=AbortAction.RAISE_EXCEPTION, key_bindings_registry=OSKeyBinder.registry) cli = CommandLineInterface(application=application, eventloop=create_eventloop()) while True: try: document = cli.run(reset_current_buffer=True) process_document(document) except KeyboardInterrupt: # A keyboardInterrupt generated possibly due to Ctrl-C print "Keyboard Interrupt Generated" continue except EOFError: print "cntl-D" sys.exit()
def main(): # We start with a `KeyBindingManager` instance, because this will already # nicely load all the default key bindings. key_bindings_manager = KeyBindingManager() # Add our own key binding to the registry of the key bindings manager. @key_bindings_manager.registry.add_binding(Keys.F4) def _(event): """ When F4 has been pressed. Insert "hello world" as text. """ event.cli.current_buffer.insert_text('hello world') @key_bindings_manager.registry.add_binding('x', 'y') def _(event): """ (Useless, but for demoing.) Typing 'xy' will insert 'z'. Note that when you type for instance 'xa', the insertion of 'x' is postponed until the 'a' is typed. because we don't know earlier whether or not a 'y' will follow. """ event.cli.current_buffer.insert_text('z') # Create a CLI with the key bindings registry of this manager. cli = CommandLineInterface(key_bindings_registry=key_bindings_manager.registry) # Read input. print('Press F4 to insert "hello world", type "xy" to insert "z":') code_obj = cli.read_input() print('You said: %s' % code_obj.text)
def loop(cmd, history_file): from prompt_toolkit import CommandLineInterface, AbortAction from prompt_toolkit import Exit from prompt_toolkit.layout import Layout from prompt_toolkit.line import Line from prompt_toolkit.renderer import Output cli_line = Line(completer=SQLCompleter(cmd.connection, cmd.lines), history=TruncatedFileHistory( history_file, max_length=MAX_HISTORY_LENGTH)) layout = Layout( before_input=CrashPrompt(cmd.lines), menus=[], lexer=SqlLexer, bottom_toolbars=[], show_tildes=False, ) key_binding_factories = _detect_key_bindings() cli = CommandLineInterface(style=MonokaiStyle, layout=layout, line=cli_line, key_binding_factories=key_binding_factories) output = Output(cli.renderer.stdout) global get_num_columns def get_num_columns(): return output.get_size().columns try: while True: doc = cli.read_input(on_exit=AbortAction.RAISE_EXCEPTION) cmd.process(doc.text) except Exit: # Quit on Ctrl-D keypress cmd.logger.warn(u'Bye!') return
def _build_cli(self, history): def set_vi_mode(value): self.vi_mode = value key_binding_manager = mssqlcli_bindings( get_vi_mode_enabled=lambda: self.vi_mode, set_vi_mode_enabled=set_vi_mode) def prompt_tokens(_): prompt = self.get_prompt() return [(Token.Prompt, prompt)] def get_continuation_tokens(cli, width): continuation = self.multiline_continuation_char * (width - 1) + ' ' return [(Token.Continuation, continuation)] get_toolbar_tokens = create_toolbar_tokens_func( lambda: self.vi_mode, None, None, None) layout = create_prompt_layout( lexer=PygmentsLexer(PostgresLexer), reserve_space_for_menu=self.min_num_menu_lines, get_prompt_tokens=prompt_tokens, get_continuation_tokens=get_continuation_tokens, get_bottom_toolbar_tokens=get_toolbar_tokens, display_completions_in_columns=self.wider_completion_menu, multiline=True, extra_input_processors=[ # Highlight matching brackets while editing. ConditionalProcessor( processor=HighlightMatchingBracketProcessor( chars='[](){}'), filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()), ]) with self._completer_lock: buf = MssqlBuffer(auto_suggest=AutoSuggestFromHistory(), always_multiline=self.multi_line, multiline_mode=self.multiline_mode, completer=self.completer, history=history, complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT) editing_mode = EditingMode.VI if self.vi_mode else EditingMode.EMACS application = Application( style=style_factory(self.syntax_style, self.cli_style), layout=layout, buffer=buf, key_bindings_registry=key_binding_manager.registry, on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ignore_case=True, editing_mode=editing_mode) cli = CommandLineInterface(application=application, eventloop=self.eventloop) return cli
def _build_cli(self): layout = create_prompt_layout( message='{0}> '.format(self.args['username']), lexer=PygmentsLexer(SqlLexer), ) buf = Buffer(completer=self.completer, history=self.history, complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT) key_binding_manager = KeyBindingManager( enable_abort_and_exit_bindings=True, ) application = Application( layout=layout, buffer=buf, key_bindings_registry=key_binding_manager.registry, on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ignore_case=True) cli = CommandLineInterface(application=application, eventloop=self.eventloop) return cli
def run(self): eventloop = create_eventloop() try: cli = CommandLineInterface(application=self.application, eventloop=eventloop) cli.run() finally: eventloop.close()
def _build_cli(self): eventloop = create_eventloop() if self._options.persistent_history: history = FileHistory( os.path.join( os.path.expanduser("~"), ".{}_history".format(self._ctx.binary_name) ) ) else: history = InMemoryHistory() layout = create_prompt_layout( lexer=PygmentsLexer(NubiaLexer), reserve_space_for_menu=5, get_prompt_tokens=self.get_prompt_tokens, get_rprompt_tokens=self._status_bar.get_rprompt_tokens, get_bottom_toolbar_tokens=self._status_bar.get_tokens, display_completions_in_columns=False, multiline=True, extra_input_processors=[ ConditionalProcessor( processor=HighlightMatchingBracketProcessor(chars="[](){}"), filter=HasFocus(DEFAULT_BUFFER) & ~IsDone(), ) ], ) buf = Buffer( completer=self._completer, history=history, auto_suggest=self._suggestor, complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT, ) # If EDITOR does not exist, take EMACS # if it does, try fit the EMACS/VI pattern using upper editor = getattr( EditingMode, os.environ.get("EDITOR", EditingMode.EMACS).upper(), EditingMode.EMACS, ) application = Application( style=shell_style, buffer=buf, editing_mode=editor, key_bindings_registry=self._registry, layout=layout, on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ignore_case=True, ) cli = CommandLineInterface(application=application, eventloop=eventloop) return cli
def main(): cli = CommandLineInterface(line=Line( history=FileHistory('.example-history-file'))) try: while True: document = cli.read_input(on_exit=AbortAction.RAISE_EXCEPTION) print('You said: ' + document.text) except Exit: pass
def _create_cli(self): """Creates the prompt_toolkit's CommandLineInterface. Args: * None. Returns: None. """ history = FileHistory(os.path.expanduser('~/.saws-history')) toolbar = Toolbar(self.get_color, self.get_fuzzy_match, self.get_shortcut_match) layout = create_default_layout( message='saws> ', reserve_space_for_menu=8, lexer=CommandLexer, get_bottom_toolbar_tokens=toolbar.handler, extra_input_processors=[ ConditionalProcessor( processor=HighlightMatchingBracketProcessor( chars='[](){}'), filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()) ] ) cli_buffer = Buffer( history=history, auto_suggest=AutoSuggestFromHistory(), enable_history_search=True, completer=self.completer, complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT) self.key_manager = KeyManager( self.set_color, self.get_color, self.set_fuzzy_match, self.get_fuzzy_match, self.set_shortcut_match, self.get_shortcut_match, self.refresh_resources_and_options, self.handle_docs) style_factory = StyleFactory(self.theme) application = Application( mouse_support=False, style=style_factory.style, layout=layout, buffer=cli_buffer, key_bindings_registry=self.key_manager.manager.registry, on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ignore_case=True) eventloop = create_eventloop() self.aws_cli = CommandLineInterface( application=application, eventloop=eventloop)
def _get_cli(self, loop): global history return CommandLineInterface( application=create_prompt_application( multiline=Condition(lambda: self._multi_line), get_prompt_tokens=self._get_prompt, history=history, wrap_lines=True, ), eventloop=loop, )
def main(): cli = CommandLineInterface( style=AnimalStyle, layout=Layout(before_input=DefaultPrompt('Give some animals: '), menus=[CompletionsMenu()]), line=Line(completer=AnimalCompleter()), create_async_autocompleters=True, ) print('Press tab to complete') code_obj = cli.read_input() print('You said: ' + code_obj.text)
def _build_cli(self, history): def set_vi_mode(value): self.vi_mode = value key_binding_manager = pgcli_bindings( get_vi_mode_enabled=lambda: self.vi_mode, set_vi_mode_enabled=set_vi_mode) def prompt_tokens(_): return [(Token.Prompt, '%s> ' % self.pgexecute.dbname)] def get_continuation_tokens(cli, width): return [(Token.Continuation, '.' * (width - 1) + ' ')] get_toolbar_tokens = create_toolbar_tokens_func( lambda: self.vi_mode, self.completion_refresher.is_refreshing) layout = create_prompt_layout( lexer=PygmentsLexer(PostgresLexer), reserve_space_for_menu=4, get_prompt_tokens=prompt_tokens, get_continuation_tokens=get_continuation_tokens, get_bottom_toolbar_tokens=get_toolbar_tokens, display_completions_in_columns=self.wider_completion_menu, multiline=True, extra_input_processors=[ # Highlight matching brackets while editing. ConditionalProcessor( processor=HighlightMatchingBracketProcessor( chars='[](){}'), filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()), ]) with self._completer_lock: buf = PGBuffer(always_multiline=self.multi_line, completer=self.completer, history=history, complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT) application = Application( style=style_factory(self.syntax_style, self.cli_style), layout=layout, buffer=buf, key_bindings_registry=key_binding_manager.registry, on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ignore_case=True) cli = CommandLineInterface(application=application) return cli
def run(self): style = style_from_dict({ Token.Prompt: 'bold', Token.Toolbar: '#ccc bg:#333', Token.Name: '#fff bold bg:#333', }) history = InMemoryHistory() eventloop = create_eventloop() app = create_prompt_application( history=history, style=style, get_bottom_toolbar_tokens=self.get_bottom_toolbar_tokens, get_prompt_tokens=self.get_prompt_tokens) self.cli = CommandLineInterface(app, eventloop) with self.cli.patch_stdout_context(raw=True): while True: try: self.cli.run() doc = self.cli.return_value() if doc is None: return cmd = shlex.split(doc.text) app.buffer.reset(append_to_history=True) if not cmd: continue elif cmd[0] in ('exit', 'quit'): self.q.put(Exit()) return elif cmd[0] == 'help': print('Help text forthcoming.') elif cmd[0] == 'skip': self.q.put(Skip()) elif cmd[0] == 'set': self.q.put( Set(cmd[1], ast.literal_eval(' '.join(cmd[2:])))) else: print('Unknown command. Try \'help\'.') except KeyboardInterrupt: continue except EOFError: self.q.put(Exit()) return except Exception as err: print(err) self.q.put(Exit()) return
def loop(cmd, history_file): key_binding_manager = KeyBindingManager( enable_search=True, enable_abort_and_exit_bindings=True) layout = create_prompt_layout( message=u'cr> ', multiline=True, lexer=SqlLexer, extra_input_processors=[ ConditionalProcessor( processor=HighlightMatchingBracketProcessor(chars='[](){}'), filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()) ]) buffer = CrashBuffer(history=TruncatedFileHistory( history_file, max_length=MAX_HISTORY_LENGTH), accept_action=AcceptAction.RETURN_DOCUMENT, completer=SQLCompleter(cmd)) buffer.complete_while_typing = lambda cli=None: cmd.should_autocomplete() application = Application( layout=layout, buffer=buffer, style=PygmentsStyle.from_defaults(pygments_style_cls=CrateStyle), key_bindings_registry=key_binding_manager.registry, editing_mode=_get_editing_mode(), on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ) eventloop = create_eventloop() output = create_output() cli = CommandLineInterface(application=application, eventloop=eventloop, output=output) def get_num_columns_override(): return output.get_size().columns cmd.get_num_columns = get_num_columns_override while True: try: doc = cli.run(reset_current_buffer=True) if doc: cmd.process(doc.text) except KeyboardInterrupt: cmd.logger.warn( "Query not cancelled. Run KILL <jobId> to cancel it") except EOFError: cmd.logger.warn(u'Bye!') return
def main(database): connection = sqlite3.connect(database) layout = Layout(before_input=DefaultPrompt('> '), lexer=SqlLexer, menus=[CompletionsMenu()]) line = Line(completer=SqlCompleter()) cli = CommandLineInterface(style=DocumentStyle, layout=layout, line=line) try: while True: document = cli.read_input(on_exit=AbortAction.RAISE_EXCEPTION) with connection: messages = connection.execute(document.text) for message in messages: print message except Exit: print 'GoodBye!'
def _build_cli(self): eventloop = create_eventloop() history = FileHistory( os.path.join( os.path.expanduser("~"), ".{}_history".format(self._ctx.binary_name), )) layout = create_prompt_layout( lexer=PygmentsLexer(NubiaLexer), reserve_space_for_menu=5, get_prompt_tokens=self.get_prompt_tokens, get_rprompt_tokens=self._status_bar.get_rprompt_tokens, get_bottom_toolbar_tokens=self._status_bar.get_tokens, display_completions_in_columns=False, multiline=True, extra_input_processors=[ ConditionalProcessor( processor=HighlightMatchingBracketProcessor( chars="[](){}"), filter=HasFocus(DEFAULT_BUFFER) & ~IsDone(), ) ], ) buf = Buffer( completer=self._completer, history=history, auto_suggest=self._suggestor, complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT, ) application = Application( style=shell_style, buffer=buf, key_bindings_registry=self._registry, layout=layout, on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ignore_case=True, ) cli = CommandLineInterface(application=application, eventloop=eventloop) return cli
def _create_cli(self): self._create_layout() self._create_buffer() self._create_style() self._create_manage() application = Application(layout=self.layout, buffer=self.buffer, style=self.style, key_bindings_registry=self.manager.registry, mouse_support=False, on_exit=AbortAction.RAISE_EXCEPTION, on_abort=AbortAction.RETRY, ignore_case=True) event_loop = create_eventloop() self.network_cli = CommandLineInterface(application=application, eventloop=event_loop)
def __init__(self, parser, engine, options=None): self.parser = parser self.engine = engine self.options = options if options is not None else {} util.ensure_data_dir_exists() application = create_prompt_application( message='> ', lexer=PygmentsLexer(SqlLexer), history=FileHistory(os.path.expanduser('~/.aq/history')), completer=AqCompleter(schemas=engine.available_schemas, tables=engine.available_tables), auto_suggest=AutoSuggestFromHistory(), validator=QueryValidator(parser), on_abort=AbortAction.RETRY, ) loop = create_eventloop() self.cli = CommandLineInterface(application=application, eventloop=loop) self.patch_context = self.cli.patch_stdout_context()
def run_cli(self): """ Run the main loop """ print(u'Version:', __version__) print(u'Home: https://github.com/glasslion/saltcli') history = FileHistory(os.path.expanduser('~/.saltcli-history')) layout = create_prompt_layout( message=u'saltcli> ', ) application = Application( layout=layout ) eventloop = create_eventloop() self.cli = CommandLineInterface( application=application, eventloop=eventloop) while True: try: document = self.cli.run() if quit_command(document.text): raise EOFError except KeyboardInterrupt: # user pressed Ctrl + C click.echo('') except EOFError: break except Exception as ex: self.logger.debug('Exception: %r.', ex) self.logger.error("traceback: %r", traceback.format_exc()) click.secho("{0}".format(ex), fg='red') break print('Goodbye!')
def main(): layout = Layout(before_input=DefaultPrompt('> '), menus=[CompletionMenu()]) line = Line(RESTCompleter()) cli = CommandLineInterface(style=DocumentStyle, layout=layout, line=line) try: while True: document = cli.read_input(on_exit=AbortAction.RAISE_EXCEPTION) input_args = document.text.split(' ') if len(input_args) < 2: raise AssertionError( "Must provide at least a method and a url") response = process_request(input_args) print 'Response:', response.json() except Exit: print 'GoodBye!'
def cli(database, user, password, host, port): from pgcli import __file__ as package_root package_root = os.path.dirname(package_root) default_config = os.path.join(package_root, 'pgclirc') # Write default config. write_default_config(default_config, '~/.pgclirc') # Load config. config = load_config('~/.pgclirc') # Connect to the database. try: pgexecute = PGExecute(database, user, password, host, port) except Exception as e: click.secho(e.message, err=True, fg='red') exit(1) layout = Layout(before_input=DefaultPrompt('%s> ' % database), menus=[CompletionsMenu()], lexer=SqlLexer) completer = PGCompleter(config.getboolean('main', 'smart_completion')) completer.extend_special_commands(pgexecute.special_commands.keys()) completer.extend_table_names(pgexecute.tables()) completer.extend_column_names(pgexecute.all_columns()) line = Line(completer=completer, history=FileHistory(os.path.expanduser('~/.pgcli-history'))) cli = CommandLineInterface(style=PGStyle, layout=layout, line=line) try: while True: document = cli.read_input(on_exit=AbortAction.RAISE_EXCEPTION) try: rows, headers, status = pgexecute.run(document.text) if rows: print(tabulate(rows, headers, tablefmt='psql')) print(status) except Exception as e: click.secho(e.message, err=True, fg='red') except Exit: print ('GoodBye!')
def __init__(self, style): self._commands = {} for d in dir(self.__class__): if d.startswith('do_'): name = d[3:] func = getattr(self, d) doc = textwrap.dedent(func.__doc__ or '') self._commands[name] = (func, doc) self._history = InMemoryHistory() self._application = create_prompt_application( get_prompt_tokens=self.get_prompt_tokens, style=style, on_abort=AbortAction.RETURN_NONE, history=self._history) self._cli = CommandLineInterface(application=self._application, output=create_output(true_color=True), eventloop=create_asyncio_eventloop()) self._style = style