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=True,
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 _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 run(self):
neo4j = Neo4j(self.host, self.port, self.username, self.password)
try:
labels = neo4j.labels()
relationship_types = neo4j.relationship_types()
properties = neo4j.properties()
except Unauthorized:
print("Unauthorized. See cycli --help for authorization instructions.")
return
except SocketError:
print("Connection refused. Is Neo4j turned on?")
return
completer = CypherCompleter(labels, relationship_types, properties)
layout = create_default_layout(
lexer=CypherLexer,
get_prompt_tokens=get_tokens,
reserve_space_for_menu=True
)
buff = CypherBuffer(
history=History(),
completer=completer,
complete_while_typing=Always()
)
application = Application(
style=CypherStyle,
buffer=buff,
layout=layout,
on_exit=AbortAction.RAISE_EXCEPTION
)
cli = CommandLineInterface(application=application, eventloop=create_eventloop())
try:
while True:
document = cli.run()
query = document.text
if query in ["quit", "exit"]:
raise Exception
elif query == "help":
print(help_text())
else:
results = neo4j.cypher(query)
print(results)
except Exception:
print("Goodbye!")
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 create_cli(self):
"""Creates the prompt_toolkit's CommandLineInterface.
Long description.
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=True,
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,
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,
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 create_cli_layout(self):
from .lexer import AzureShellLexer
lexer = AzureShellLexer
return create_default_layout(
message=u'azure> ',
reserve_space_for_menu=8,
lexer=lexer,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
])
def _build_cli(self):
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)]
get_toolbar_tokens = create_toolbar_tokens_func(
lambda: self.vi_mode, self.completion_refresher.is_refreshing)
layout = create_default_layout(
lexer=PostgresLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_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()),
])
history_file = self.config['main']['history_file']
with self._completer_lock:
buf = PGBuffer(
always_multiline=self.multi_line,
completer=self.completer,
history=FileHistory(os.path.expanduser(history_file)),
complete_while_typing=Always())
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,
ignore_case=True)
cli = CommandLineInterface(
application=application,
eventloop=create_eventloop())
return cli
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)]
get_toolbar_tokens = create_toolbar_tokens_func(
lambda: self.vi_mode, self.completion_refresher.is_refreshing)
layout = create_default_layout(
lexer=PostgresLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_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())
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,
ignore_case=True)
cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
return cli
def __init__(self):
def get_toolbar(self):
return [(Token.Toolbar.Status.Key, '[msx] Help [ctrl+q] Exit')
]
updated_style = style_from_pygments(
TangoStyle, {
Token.Menu.Completions.Completion.Current:
'bg:#acba36 #000000',
Token.Menu.Completions.Completion: 'bg:#008888 #ffffff',
Token.Menu.Completions.ProgressBar: 'bg:#acba36',
Token.Scrollbar: 'bg:#acba36',
Token.Scrollbar.Button: 'bg:#003333',
Token.Toolbar: '#ffffff bg:#333333',
Token: '#00ffff bold',
Token.Toolbar.Status.Key: '#ff0000'
})
history = InMemoryHistory()
layout = create_default_layout(message=u'musixli:$>> ',
get_bottom_toolbar_tokens=get_toolbar)
cli_buffer = Buffer(history=history,
auto_suggest=AutoSuggestFromHistory(),
enable_history_search=True,
completer=self.musix_completer,
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT)
loop = create_eventloop()
self.manager = KeyBindingManager()
@self.manager.registry.add_binding(Keys.ControlQ, eager=True)
def exit_(event):
sys.exit()
application = Application(
key_bindings_registry=self.manager.registry,
layout=layout,
mouse_support=False,
buffer=cli_buffer,
style=updated_style,
ignore_case=True,
)
self.cli = CommandLineInterface(application=application,
eventloop=loop)
def run_cli(self):
sqlexecute = self.sqlexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
self.initialize_completions()
completer = self.completer
def set_key_bindings(value):
if value not in ('emacs', 'vi'):
value = 'emacs'
self.key_bindings = value
project_root = os.path.dirname(PACKAGE_ROOT)
author_file = os.path.join(project_root, 'AUTHORS')
sponsor_file = os.path.join(project_root, 'SPONSORS')
key_binding_manager = mycli_bindings(
get_key_bindings=lambda: self.key_bindings,
set_key_bindings=set_key_bindings)
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/mycli')
print('Mail: https://groups.google.com/forum/#!forum/mycli-users')
print('Home: http://mycli.net')
print('Thanks to the contributor -',
thanks_picker([author_file, sponsor_file]))
def prompt_tokens(cli):
return [(Token.Prompt, self.get_prompt(self.prompt_format))]
get_toolbar_tokens = create_toolbar_tokens_func(
lambda: self.key_bindings)
layout = create_default_layout(
lexer=MyCliLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
buf = CLIBuffer(always_multiline=self.multi_line,
completer=completer,
history=FileHistory(
os.path.expanduser('~/.mycli-history')),
complete_while_typing=Always())
application = Application(
style=style_factory(self.syntax_style),
layout=layout,
buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION)
cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
document = cli.run()
special.set_expanded_output(False)
# The reason we check here instead of inside the sqlexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the
# sqlexecute.run() statement.
if quit_command(document.text):
raise EOFError
try:
document = self.handle_editor_command(cli, document)
except RuntimeError as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg='red')
continue
destroy = confirm_destructive_query(document.text)
if destroy is None:
pass # Query was not destructive. Nothing to do here.
elif destroy is True:
self.output('Your call!')
else:
self.output('Wise choice!')
continue
# Keep track of whether or not the query is mutating. In case
# of a multi-statement query, the overall query is considered
# mutating if any one of the component statements is mutating
mutating = False
try:
logger.debug('sql: %r', document.text)
if self.logfile:
self.logfile.write('\n# %s\n' % datetime.now())
self.logfile.write(document.text)
self.logfile.write('\n')
successful = False
start = time()
res = sqlexecute.run(document.text)
duration = time() - start
successful = True
output = []
total = 0
for title, cur, headers, status in res:
logger.debug("headers: %r", headers)
logger.debug("rows: %r", cur)
logger.debug("status: %r", status)
start = time()
threshold = 1000
if (is_select(status) and cur
and cur.rowcount > threshold):
self.output(
'The result set has more than %s rows.' %
threshold,
fg='red')
if not click.confirm('Do you want to continue?'):
self.output("Aborted!", err=True, fg='red')
break
output.extend(
format_output(title, cur, headers, status,
self.table_format))
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except KeyboardInterrupt:
# Restart connection to the database
sqlexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
self.output("cancelled query", err=True, fg='red')
except NotImplementedError:
self.output('Not Yet Implemented.', fg="yellow")
except OperationalError as e:
logger.debug("Exception: %r", e)
reconnect = True
if (e.args[0] in (2003, 2006, 2013)):
reconnect = click.prompt(
'Connection reset. Reconnect (Y/n)',
show_default=False,
type=bool,
default=True)
if reconnect:
logger.debug('Attempting to reconnect.')
try:
sqlexecute.connect()
logger.debug('Reconnected successfully.')
self.output(
'Reconnected!\nTry the command again.',
fg='green')
except OperationalError as e:
logger.debug('Reconnect failed. e: %r', e)
self.output(str(e), err=True, fg='red')
continue # If reconnection failed, don't proceed further.
else: # If user chooses not to reconnect, don't proceed further.
continue
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg='red')
except Exception as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg='red')
else:
self.output_via_pager('\n'.join(output))
if special.is_timing_enabled():
self.output('Command Time: %0.03fs' % duration)
self.output('Format Time: %0.03fs' % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_dynamic_completions()
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
self.output('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
os.environ['PAGER'] = special.get_original_pager()
def run_cli(self):
sqlexecute = self.sqlexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
self.initialize_completions()
completer = self.completer
def set_key_bindings(value):
if value not in ('emacs', 'vi'):
value = 'emacs'
self.key_bindings = value
project_root = os.path.dirname(PACKAGE_ROOT)
author_file = os.path.join(project_root, 'AUTHORS')
sponsor_file = os.path.join(project_root, 'SPONSORS')
key_binding_manager = mycli_bindings(get_key_bindings=lambda: self.key_bindings,
set_key_bindings=set_key_bindings)
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/mycli')
print('Mail: https://groups.google.com/forum/#!forum/mycli-users')
print('Home: http://mycli.net')
print('Thanks to the contributor -', thanks_picker([author_file, sponsor_file]))
def prompt_tokens(cli):
return [(Token.Prompt, self.get_prompt(self.prompt_format))]
get_toolbar_tokens = create_toolbar_tokens_func(lambda: self.key_bindings)
layout = create_default_layout(lexer=MyCliLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
buf = CLIBuffer(always_multiline=self.multi_line, completer=completer,
history=FileHistory(os.path.expanduser('~/.mycli-history')),
complete_while_typing=Always())
application = Application(style=style_factory(self.syntax_style),
layout=layout, buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION)
cli = CommandLineInterface(application=application, eventloop=create_eventloop())
try:
while True:
document = cli.run()
special.set_expanded_output(False)
# The reason we check here instead of inside the sqlexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the
# sqlexecute.run() statement.
if quit_command(document.text):
raise EOFError
try:
document = self.handle_editor_command(cli, document)
except RuntimeError as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg='red')
continue
destroy = confirm_destructive_query(document.text)
if destroy is None:
pass # Query was not destructive. Nothing to do here.
elif destroy is True:
self.output('Your call!')
else:
self.output('Wise choice!')
continue
# Keep track of whether or not the query is mutating. In case
# of a multi-statement query, the overall query is considered
# mutating if any one of the component statements is mutating
mutating = False
try:
logger.debug('sql: %r', document.text)
if self.logfile:
self.logfile.write('\n# %s\n' % datetime.now())
self.logfile.write(document.text)
self.logfile.write('\n')
successful = False
start = time()
res = sqlexecute.run(document.text)
duration = time() - start
successful = True
output = []
total = 0
for title, cur, headers, status in res:
logger.debug("headers: %r", headers)
logger.debug("rows: %r", cur)
logger.debug("status: %r", status)
start = time()
threshold = 1000
if (is_select(status) and
cur and cur.rowcount > threshold):
self.output('The result set has more than %s rows.'
% threshold, fg='red')
if not click.confirm('Do you want to continue?'):
self.output("Aborted!", err=True, fg='red')
break
output.extend(format_output(title, cur, headers,
status, self.table_format))
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except KeyboardInterrupt:
# Restart connection to the database
sqlexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
self.output("cancelled query", err=True, fg='red')
except NotImplementedError:
self.output('Not Yet Implemented.', fg="yellow")
except OperationalError as e:
logger.debug("Exception: %r", e)
reconnect = True
if (e.args[0] in (2003, 2006, 2013)):
reconnect = click.prompt('Connection reset. Reconnect (Y/n)',
show_default=False, type=bool, default=True)
if reconnect:
logger.debug('Attempting to reconnect.')
try:
sqlexecute.connect()
logger.debug('Reconnected successfully.')
self.output('Reconnected!\nTry the command again.', fg='green')
except OperationalError as e:
logger.debug('Reconnect failed. e: %r', e)
self.output(str(e), err=True, fg='red')
continue # If reconnection failed, don't proceed further.
else: # If user chooses not to reconnect, don't proceed further.
continue
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg='red')
except Exception as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg='red')
else:
self.output_via_pager('\n'.join(output))
if special.is_timing_enabled():
self.output('Command Time: %0.03fs' % duration)
self.output('Format Time: %0.03fs' % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_dynamic_completions()
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
self.output('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
os.environ['PAGER'] = special.get_original_pager()
def run_cli(self):
pgexecute = self.pgexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
self.refresh_completions()
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)
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/pgcli')
print('Mail: https://groups.google.com/forum/#!forum/pgcli')
print('Home: http://pgcli.com')
def prompt_tokens(cli):
return [(Token.Prompt, '%s> ' % pgexecute.dbname)]
get_toolbar_tokens = create_toolbar_tokens_func(
lambda: self.vi_mode, self.completion_refresher.is_refreshing)
layout = create_default_layout(
lexer=PostgresLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_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()),
])
history_file = self.config['main']['history_file']
with self._completer_lock:
buf = PGBuffer(always_multiline=self.multi_line,
completer=self.completer,
history=FileHistory(
os.path.expanduser(history_file)),
complete_while_typing=Always())
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,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
document = self.cli.run()
# The reason we check here instead of inside the pgexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the pgexecute.run()
# statement.
if quit_command(document.text):
raise EOFError
try:
document = self.handle_editor_command(self.cli, document)
except RuntimeError as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
continue
# Keep track of whether or not the query is mutating. In case
# of a multi-statement query, the overall query is considered
# mutating if any one of the component statements is mutating
mutating = False
try:
logger.debug('sql: %r', document.text)
successful = False
# Initialized to [] because res might never get initialized
# if an exception occurs in pgexecute.run(). Which causes
# finally clause to fail.
res = []
# Run the query.
start = time()
res = pgexecute.run(document.text,
self.pgspecial,
on_error=self.on_error)
output = []
total = 0
for title, cur, headers, status in res:
logger.debug("headers: %r", headers)
logger.debug("rows: %r", cur)
logger.debug("status: %r", status)
threshold = 1000
if (is_select(status) and cur
and cur.rowcount > threshold):
click.secho(
'The result set has more than %s rows.' %
threshold,
fg='red')
if not click.confirm('Do you want to continue?'):
click.secho("Aborted!", err=True, fg='red')
break
if self.pgspecial.auto_expand:
max_width = self.cli.output.get_size().columns
else:
max_width = None
formatted = format_output(
title, cur, headers, status, self.table_format,
self.pgspecial.expanded_output, max_width)
output.extend(formatted)
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except KeyboardInterrupt:
# Restart connection to the database
pgexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
click.secho("cancelled query", err=True, fg='red')
except NotImplementedError:
click.secho('Not Yet Implemented.', fg="yellow")
except OperationalError as e:
reconnect = True
if ('server closed the connection'
in utf8tounicode(e.args[0])):
reconnect = click.prompt(
'Connection reset. Reconnect (Y/n)',
show_default=False,
type=bool,
default=True)
if reconnect:
try:
pgexecute.connect()
click.secho(
'Reconnected!\nTry the command again.',
fg='green')
except OperationalError as e:
click.secho(str(e), err=True, fg='red')
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
except Exception as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
else:
successful = True
try:
click.echo_via_pager('\n'.join(output))
except KeyboardInterrupt:
pass
if self.pgspecial.timing_enabled:
print('Time: %0.03fs' % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(
need_completion_reset(document.text))
# Refresh search_path to set default schema.
if need_search_path_refresh(document.text):
logger.debug('Refreshing search path')
with self._completer_lock:
self.completer.set_search_path(
pgexecute.search_path())
logger.debug('Search path: %r',
self.completer.search_path)
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
print('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
def run(self):
neo4j = Neo4j(self.host, self.port, self.username, self.password, self.ssl)
neo4j.connect()
self.neo4j = neo4j
try:
labels = neo4j.labels()
relationship_types = neo4j.relationship_types()
properties = neo4j.properties()
except Unauthorized:
print("Unauthorized. See cycli --help for authorization instructions.")
return
except SocketError:
print("Connection refused. Is Neo4j turned on?")
return
if self.filename:
queries = self.filename.read()
queries = queries.split(";")[:-1]
for query in queries:
query += ";"
query = query.strip()
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("\nVersion: {}".format(__version__))
print("Bug reports: https://github.com/nicolewhite/cycli/issues\n")
completer = CypherCompleter(labels, relationship_types, properties)
layout = create_default_layout(
lexer=CypherLexer,
get_prompt_tokens=get_tokens,
reserve_space_for_menu=True
)
buff = CypherBuffer(
history=FileHistory(filename=os.path.expanduser('~/.cycli_history')),
completer=completer,
complete_while_typing=Always()
)
application = Application(
style=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 Exception:
print("Goodbye!")
def run_cli(self):
pgexecute = self.pgexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
completer = self.completer
self.refresh_completions()
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)
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/pgcli')
print('Mail: https://groups.google.com/forum/#!forum/pgcli')
print('Home: http://pgcli.com')
def prompt_tokens(cli):
return [(Token.Prompt, '%s> ' % pgexecute.dbname)]
get_toolbar_tokens = create_toolbar_tokens_func(lambda: self.vi_mode)
layout = create_default_layout(lexer=PostgresLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
extra_input_processors=[
# Highlight matching brackets while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
history_file = self.config['main']['history_file']
buf = PGBuffer(always_multiline=self.multi_line, completer=completer,
history=FileHistory(os.path.expanduser(history_file)),
complete_while_typing=Always())
application = Application(style=style_factory(self.syntax_style),
layout=layout, buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION)
cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
document = cli.run()
# The reason we check here instead of inside the pgexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the pgexecute.run()
# statement.
if quit_command(document.text):
raise EOFError
try:
document = self.handle_editor_command(cli, document)
except RuntimeError as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
continue
# Keep track of whether or not the query is mutating. In case
# of a multi-statement query, the overall query is considered
# mutating if any one of the component statements is mutating
mutating = False
try:
logger.debug('sql: %r', document.text)
successful = False
# Initialized to [] because res might never get initialized
# if an exception occurs in pgexecute.run(). Which causes
# finally clause to fail.
res = []
start = time()
# Run the query.
res = pgexecute.run(document.text, self.pgspecial)
duration = time() - start
successful = True
output = []
total = 0
for title, cur, headers, status in res:
logger.debug("headers: %r", headers)
logger.debug("rows: %r", cur)
logger.debug("status: %r", status)
start = time()
threshold = 1000
if (is_select(status) and
cur and cur.rowcount > threshold):
click.secho('The result set has more than %s rows.'
% threshold, fg='red')
if not click.confirm('Do you want to continue?'):
click.secho("Aborted!", err=True, fg='red')
break
formatted = format_output(title, cur, headers, status,
self.table_format,
self.pgspecial.expanded_output)
output.extend(formatted)
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except KeyboardInterrupt:
# Restart connection to the database
pgexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
click.secho("cancelled query", err=True, fg='red')
except NotImplementedError:
click.secho('Not Yet Implemented.', fg="yellow")
except OperationalError as e:
reconnect = True
if ('server closed the connection' in utf8tounicode(e.args[0])):
reconnect = click.prompt('Connection reset. Reconnect (Y/n)',
show_default=False, type=bool, default=True)
if reconnect:
try:
pgexecute.connect()
click.secho('Reconnected!\nTry the command again.', fg='green')
except OperationalError as e:
click.secho(str(e), err=True, fg='red')
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
except Exception as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
else:
click.echo_via_pager('\n'.join(output))
if self.pgspecial.timing_enabled:
print('Command Time: %0.03fs' % duration)
print('Format Time: %0.03fs' % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions()
# Refresh search_path to set default schema.
if need_search_path_refresh(document.text):
logger.debug('Refreshing search path')
completer.set_search_path(pgexecute.search_path())
logger.debug('Search path: %r', completer.search_path)
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
print ('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
def run_cli(self):
vexecute = self.vexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
completer = self.completer
self.refresh_completions()
def set_vi_mode(value):
self.vi_mode = value
key_binding_manager = vcli_bindings(
get_vi_mode_enabled=lambda: self.vi_mode,
set_vi_mode_enabled=set_vi_mode)
click.secho('Version: %s' % __version__)
def prompt_tokens(cli):
return [(Token.Prompt, '%s=> ' % vexecute.dbname)]
get_toolbar_tokens = create_toolbar_tokens_func(lambda: self.vi_mode,
self.completion_refresher.is_refreshing)
input_processors = [
# Highlight matching brackets while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
]
layout = create_default_layout(
lexer=PostgresLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
multiline=True,
extra_input_processors=input_processors)
history_file = self.config['main']['history_file']
with self._completer_lock:
buf = VBuffer(always_multiline=self.multi_line, completer=self.completer,
history=FileHistory(os.path.expanduser(history_file)),
complete_while_typing=Always())
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,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
document = self.cli.run()
# The reason we check here instead of inside the vexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the vexecute.run()
# statement.
if quit_command(document.text):
raise EOFError
try:
document = self.handle_editor_command(self.cli, document)
except RuntimeError as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
continue
# Keep track of whether or not the query is mutating. In case
# of a multi-statement query, the overall query is considered
# mutating if any one of the component statements is mutating
mutating = False
try:
logger.debug('sql: %r', document.text)
successful = False
# Initialized to [] because res might never get initialized
# if an exception occurs in vexecute.run(). Which causes
# finally clause to fail.
res = []
start = time()
# Run the query.
res = vexecute.run(document.text, self.vspecial)
duration = time() - start
file_output = None
stdout_output = []
total = 0
for title, cur, headers, status, force_stdout in res:
logger.debug("headers: %r", headers)
logger.debug("rows: %r", cur)
logger.debug("status: %r", status)
start = time()
threshold = 1000
if (is_select(status) and
cur and cur.rowcount > threshold):
click.secho('The result set has more than %s rows.'
% threshold, fg='red')
if not click.confirm('Do you want to continue?'):
click.secho("Aborted!", err=True, fg='red')
break
formatted = format_output(title, cur, headers, status,
self.table_format,
self.vspecial.expanded_output,
self.vspecial.aligned,
self.vspecial.show_header)
if self.vspecial.output is not sys.stdout:
file_output = self.vspecial.output
if force_stdout or not file_output:
output = stdout_output
else:
output = file_output
write_output(output, formatted)
if hasattr(cur, 'rowcount'):
if self.vspecial.show_header:
if cur.rowcount == 1:
write_output(output, '(1 row)')
elif headers:
write_output(output, '(%d rows)' % cur.rowcount)
if document.text.startswith('\\') and cur.rowcount == 0:
stdout_output = ['No matching relations found.']
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except KeyboardInterrupt:
# Restart connection to the database
vexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
click.secho("cancelled query", err=True, fg='red')
except NotImplementedError:
click.secho('Not Yet Implemented.', fg="yellow")
except errors.ConnectionError as e:
reconnect = True
if ('Connection is closed' in utf8tounicode(e.args[0])):
reconnect = click.prompt('Connection reset. Reconnect (Y/n)',
show_default=False, type=bool, default=True)
if reconnect:
try:
vexecute.connect()
click.secho('Reconnected!\nTry the command again.', fg='green')
except errors.DatabaseError as e:
click.secho(str(e), err=True, fg='red')
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
except Exception as e:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
else:
successful = True
if stdout_output:
output = '\n'.join(stdout_output)
try:
click.echo_via_pager(output)
except KeyboardInterrupt:
pass
if file_output:
try:
file_output.flush()
except KeyboardInterrupt:
pass
if self.vspecial.timing_enabled:
print('Time: command: %0.03fs, total: %0.03fs' % (duration, total))
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(need_completion_reset(document.text))
# Refresh search_path to set default schema.
if need_search_path_refresh(document.text):
logger.debug('Refreshing search path')
with self._completer_lock:
self.completer.set_search_path(vexecute.search_path())
logger.debug('Search path: %r', self.completer.search_path)
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
print ('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
def run_cli(self):
"""
Run the main loop
"""
print('Version:', __version__)
print('Home: http://wharfee.com')
history = FileHistory(os.path.expanduser('~/.wharfee-history'))
toolbar_handler = create_toolbar_handler(self.get_long_options, self.get_fuzzy_match)
layout = create_default_layout(
message='wharfee> ',
reserve_space_for_menu=True,
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,
completer=self.completer,
complete_while_typing=Always())
manager = get_key_manager(
self.set_long_options,
self.get_long_options,
self.set_fuzzy_match,
self.get_fuzzy_match)
application = Application(
style=style_factory(self.theme),
layout=layout,
buffer=cli_buffer,
key_bindings_registry=manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
ignore_case=True)
eventloop = create_eventloop()
self.dcli = CommandLineInterface(
application=application,
eventloop=eventloop)
while True:
try:
document = self.dcli.run()
self.handler.handle_input(document.text)
if isinstance(self.handler.output, GeneratorType):
output_stream(self.handler.command,
self.handler.output,
self.handler.logs)
elif self.handler.output is not None:
lines = format_data(
self.handler.command,
self.handler.output)
click.echo_via_pager('\n'.join(lines))
if self.handler.after:
for line in self.handler.after():
click.echo(line)
self.refresh_completions()
except OptionError as ex:
self.logger.debug('Error: %r.', ex)
self.logger.error("traceback: %r", traceback.format_exc())
click.secho(ex.msg, fg='red')
except KeyboardInterrupt:
# user pressed Ctrl + C
if self.handler.after:
click.echo('')
for line in self.handler.after():
click.echo(line)
self.refresh_completions()
except DockerPermissionException as ex:
self.logger.debug('Permission exception: %r.', ex)
self.logger.error("traceback: %r", traceback.format_exc())
click.secho(ex.message, fg='red')
except EOFError:
# exit out of the CLI
break
# TODO: uncomment for release
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
self.revert_less_opts()
self.write_config_file()
print('Goodbye!')
def _create_layout(self):
self.layout = create_default_layout(
message='network > ',
lexer=CommandLexer,
get_bottom_toolbar_tokens=create_toolbar_handler(
self.get_long_options, self.get_fuzzy_match))
def loop(cmd, history_file):
from prompt_toolkit import CommandLineInterface, AbortAction, Application
from prompt_toolkit.interface import AcceptAction
from prompt_toolkit.enums import DEFAULT_BUFFER
from prompt_toolkit.layout.processors import (
HighlightMatchingBracketProcessor,
ConditionalProcessor
)
from prompt_toolkit.key_binding.manager import KeyBindingManager
from prompt_toolkit.shortcuts import (create_default_layout,
create_default_output,
create_eventloop)
key_binding_manager = KeyBindingManager(
enable_search=True,
enable_abort_and_exit_bindings=True,
enable_vi_mode=Condition(lambda cli: _enable_vi_mode()))
layout = create_default_layout(
message=u'cr> ',
multiline=True,
lexer=SqlLexer,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
]
)
cli_buffer = CrashBuffer(
history=TruncatedFileHistory(history_file, max_length=MAX_HISTORY_LENGTH),
accept_action=AcceptAction.RETURN_DOCUMENT,
completer=SQLCompleter(cmd.connection, cmd.lines),
complete_while_typing=Always()
)
application = Application(
layout=layout,
style=CrateStyle,
buffer=cli_buffer,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
)
eventloop = create_eventloop()
output = create_default_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()
if doc:
cmd.process(doc.text)
except EOFError:
cmd.logger.warn(u'Bye!')
return
def run_cli(self):
"""
Run the main loop
"""
print('Version:', __version__)
print('Home: http://dockercli.com')
history = FileHistory(os.path.expanduser('~/.dockercli-history'))
toolbar_handler = create_toolbar_handler(self.get_long_options, self.get_fuzzy_match)
layout = create_default_layout(
message='dockercli> ',
reserve_space_for_menu=True,
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,
completer=self.completer,
complete_while_typing=Always())
manager = get_key_manager(
self.set_long_options,
self.get_long_options,
self.set_fuzzy_match,
self.get_fuzzy_match)
application = Application(
style=style_factory(self.theme),
layout=layout,
buffer=cli_buffer,
key_bindings_registry=manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION)
eventloop = create_eventloop()
self.dcli = CommandLineInterface(
application=application,
eventloop=eventloop)
while True:
try:
document = self.dcli.run()
self.handler.handle_input(document.text)
if isinstance(self.handler.output, GeneratorType):
output_stream(self.handler.command,
self.handler.output,
self.handler.logs)
elif self.handler.output is not None:
lines = format_data(
self.handler.command,
self.handler.output)
click.echo_via_pager('\n'.join(lines))
if self.handler.after:
for line in self.handler.after():
click.echo(line)
self.refresh_completions()
except OptionError as ex:
click.secho(ex.msg, fg='red')
except KeyboardInterrupt:
# user pressed Ctrl + C
if self.handler.after:
click.echo('')
for line in self.handler.after():
click.echo(line)
self.refresh_completions()
except DockerPermissionException as ex:
click.secho(ex.message, fg='red')
except EOFError:
# exit out of the CLI
break
# TODO: uncomment for release
except Exception as ex:
click.secho("{0}".format(ex), fg='red')
break
self.revert_less_opts()
self.write_config_file()
print('Goodbye!')
