def _handle_exception(cli, e, style=style_from_pygments(DefaultStyle)):
output = cli.output
# Instead of just calling ``traceback.format_exc``, we take the
# traceback and skip the bottom calls of this framework.
t, v, tb = sys.exc_info()
tblist = traceback.extract_tb(tb)
for line_nr, tb_tuple in enumerate(tblist):
if tb_tuple[0] == '<stdin>':
tblist = tblist[line_nr:]
break
l = traceback.format_list(tblist)
if l:
l.insert(0, "Traceback (most recent call last):\n")
l.extend(traceback.format_exception_only(t, v))
# For Python2: `format_list` and `format_exception_only` return
# non-unicode strings. Ensure that everything is unicode.
if six.PY2:
l = [i.decode('utf-8') if isinstance(i, six.binary_type) else i for i in l]
tb = ''.join(l)
# Format exception and write to output.
# (We use the default style. Most other styles result
# in unreadable colors for the traceback.)
tokens = _lex_python_traceback(tb)
cli.print_tokens(tokens, style=style)
output.write('%s\n' % e)
output.flush()
def _handle_exception(cls, cli, e):
output = cli.output
# Instead of just calling ``traceback.format_exc``, we take the
# traceback and skip the bottom calls of this framework.
t, v, tb = sys.exc_info()
tblist = traceback.extract_tb(tb)
for line_nr, tb_tuple in enumerate(tblist):
if tb_tuple[0] == '<stdin>':
tblist = tblist[line_nr:]
break
l = traceback.format_list(tblist)
if l:
l.insert(0, "Traceback (most recent call last):\n")
l.extend(traceback.format_exception_only(t, v))
tb = ''.join(l)
# Format exception and write to output.
# (We use the default style. Most other styles result
# in unreadable colors for the traceback.)
tokens = _lex_python_traceback(tb)
cli.print_tokens(tokens, style=style_from_pygments(DefaultStyle))
output.write('%s\n\n' % e)
output.flush()
def _handle_exception(cls, cli, e):
output = cli.output
# Instead of just calling ``traceback.format_exc``, we take the
# traceback and skip the bottom calls of this framework.
t, v, tb = sys.exc_info()
tblist = traceback.extract_tb(tb)
for line_nr, tb_tuple in enumerate(tblist):
if tb_tuple[0] == '<stdin>':
tblist = tblist[line_nr:]
break
l = traceback.format_list(tblist)
if l:
l.insert(0, "Traceback (most recent call last):\n")
l.extend(traceback.format_exception_only(t, v))
tb = ''.join(l)
# Format exception and write to output.
# (We use the default style. Most other styles result
# in unreadable colors for the traceback.)
tokens = _lex_python_traceback(tb)
cli.print_tokens(tokens, style=style_from_pygments(DefaultStyle))
output.write('%s\n' % e)
output.flush()
def _handle_exception(cls, cli, e):
output = cli.output
# Instead of just calling ``traceback.format_exc``, we take the
# traceback and skip the bottom calls of this framework.
t, v, tb = sys.exc_info()
tblist = traceback.extract_tb(tb)
for line_nr, tb_tuple in enumerate(tblist):
if tb_tuple[0] == '<stdin>':
tblist = tblist[line_nr:]
break
l = traceback.format_list(tblist)
if l:
l.insert(0, "Traceback (most recent call last):\n")
l.extend(traceback.format_exception_only(t, v))
# For Python2: `format_list` and `format_exception_only` return
# non-unicode strings. Ensure that everything is unicode.
if six.PY2:
l = [i.decode('utf-8') if isinstance(i, six.binary_type) else i for i in l]
tb = ''.join(l)
# Format exception and write to output.
# (We use the default style. Most other styles result
# in unreadable colors for the traceback.)
tokens = _lex_python_traceback(tb)
cli.print_tokens(tokens, style=style_from_pygments(DefaultStyle))
output.write('%s\n' % e)
output.flush()
def __init__(self, uri=None, **settings):
self.output_file = settings.pop("file", None)
verbose = settings.pop("verbose", False)
connection_data = get_connection_data(uri, **settings)
try:
self.graph = Graph(uri, **settings)
except ServiceUnavailable as error:
raise ConsoleError("Could not connect to {} -- {}".format(
connection_data["uri"], error))
try:
makedirs(HISTORY_FILE_DIR)
except OSError:
pass
self.history = FileHistory(path_join(HISTORY_FILE_DIR, HISTORY_FILE))
self.prompt_args = {
"history":
self.history,
"lexer":
PygmentsLexer(CypherLexer),
"style":
style_from_pygments(
VimStyle, {
Token.Prompt:
"#ansi{}".format(self.prompt_colour.replace(
"cyan", "teal")),
Token.TxCounter:
"#ansi{} bold".format(
self.tx_colour.replace("cyan", "teal")),
})
}
self.lexer = CypherLexer()
self.result_writer = Table.write
if verbose:
from neo4j.util import watch
self.watcher = watch("neo4j.%s" % connection_data["scheme"])
self.commands = {
"//": self.set_multi_line,
"/e": self.edit,
"/?": self.help,
"/h": self.help,
"/help": self.help,
"/x": self.exit,
"/exit": self.exit,
"/play": self.play,
"/csv": self.set_csv_result_writer,
"/table": self.set_tabular_result_writer,
"/tsv": self.set_tsv_result_writer,
"/config": self.config,
"/kernel": self.kernel,
}
self.tx = None
self.tx_counter = 0
def cmdloop(self, intro=None):
"""A Cmd.cmdloop implementation"""
style = style_from_pygments(BasicStyle, style_dict)
self.preloop()
stop = None
while not stop:
line = prompt(get_prompt_tokens=get_prompt_tokens, lexer=lexer,
get_bottom_toolbar_tokens=get_bottom_toolbar_tokens,
history=history, style=style, true_color=True,
on_exit='return-none', on_abort='return-none',
completer=QCompleter())
if line is None or line.strip() == r'\\':
raise SystemExit
else:
line = self.precmd(line)
stop = self.onecmd(line)
stop = self.postcmd(stop, line)
self.postloop()
def app_initialize(self, mp):
if sys.platform.startswith('win'):
callbacks.ENCODING = interface.encoding()
if interface.get_option("rice.editing_mode", "emacs") in ["vim", "vi"]:
mp.app.editing_mode = EditingMode.VI
else:
mp.app.editing_mode = EditingMode.EMACS
color_scheme = interface.get_option("rice.color_scheme", "native")
mp.style = style_from_pygments(get_style_by_name(color_scheme))
mp.app.auto_indentation = interface.get_option("rice.auto_indentation", True)
mp.app.tab_size = int(interface.get_option("rice.tab_size", 4))
mp.complete_while_typing = interface.get_option("rice.complete_while_typing", True)
prompt = interface.get_option("rice.prompt", None)
if prompt:
mp.set_prompt_mode_message("r", ANSI(prompt))
else:
sys_prompt = interface.get_option("prompt")
if sys_prompt == "> ":
prompt = PROMPT
else:
prompt = sys_prompt
mp.default_prompt = prompt
mp.set_prompt_mode_message("r", ANSI(prompt))
interface.set_option("prompt", prompt)
shell_prompt = interface.get_option("rice.shell_prompt", SHELL_PROMPT)
mp.set_prompt_mode_message("shell", ANSI(shell_prompt))
set_width_on_resize = interface.get_option("setWidthOnResize", True)
mp.auto_width = interface.get_option("rice.auto_width", set_width_on_resize)
if mp.auto_width:
interface.set_option("width", mp.app.output.get_size().columns)
# necessary on windows
interface.set_option("menu.graphics", False)
# print welcome message
sys.stdout.write(interface.r_version())
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 __call__(self):
print_(self.get_title())
while True:
try:
request = prompt(
'>>> ',
multiline=True,
get_title=self.get_title,
get_continuation_tokens=self.continuation_tokens,
key_bindings_registry=self.kbmgr.registry,
lexer=PygmentsLexer(GraphDSLLexer),
style=style_from_pygments(
get_style_by_name(self.color_scheme),
{}
),
history=self.histmgr.history,
enable_history_search=True,
)
requests = [req.strip() for req in request.split(';')]
for request in requests:
if request:
try:
result = self.graph(request)
self.histmgr.add_to_history(request)
print_(result)
except Exception as err:
print_('Error:', err)
except EOFError:
break
self.histmgr.close()
print_('Goodbye!')
Name.Decorator: '#ffa500',
Generic.Heading: 'bold #ffffff',
Generic.Subheading: 'underline #ffffff',
Generic.Deleted: '#d22323',
Generic.Inserted: '#589819',
Generic.Error: '#d22323',
Generic.Emph: 'italic',
Generic.Strong: 'bold',
Generic.Prompt: '#eeeeee',
Generic.Output: '#ffffff',
Generic.Traceback: '#d22323',
Error: 'bg:#e3d2d2 #a61717'
}
CHStyle = style_from_pygments(CHPygmentsStyle)
class Echo(object):
def __init__(self, verbose=True, colors=True):
self.verbose = verbose
self.colors = colors
def _echo(self, *args, **kwargs):
if not self.colors:
kwargs.pop('fg', None)
if self.verbose:
return secho(*args, **kwargs)
def info(self, text, *args, **kwargs):
self._echo(text, *args, **kwargs)
from pygments.lexer import RegexLexer, include, bygroups, words
from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
Number, Punctuation
from pygments.lexers.python import PythonLexer
from pygments.styles.paraiso_dark import ParaisoDarkStyle
from prompt_toolkit.styles import style_from_pygments
# Colour pallet
# #383830 #49483e #75715e #a59f85 #d0c8c6
# #e9e1dd #f9f8f5 #cb6077 #d28b71 #f4bc87
# #beb55b #7bbda4 #8ab3b5 #a89bb9 #bb9584
ripl_style = style_from_pygments(ParaisoDarkStyle, {
Token.Comment: '#75715e italic',
Token.Punctuation.Quoted: '#a89bb9',
})
class RiplLexer(RegexLexer):
name = 'RIPL'
aliases = ['Ripl']
filenames = ['*.rpl']
special_forms = (
'car', 'cdr', 'import', 'do', 'is', 'in', 'eval',
'quasiquote', 'unquote', 'unquote-splice', 'quote')
declarations = 'define defn defmacro defclass lambda setv let'.split()
builtins = (
default_style = ''
styles = {
Generic.Inserted: '#88f',
Generic.Heading: 'bold #8f8',
Generic.Error: 'bold #f00',
Text: 'bold #ccf',
# Error is used for, at least, text that doesn't match any token
# (when using a RegexLexer derivitive). As such, it is used for
# text that is being actively typed that doesn't match anything
# *yet*. Should probably leave it as unformatted.
#Error: 'italic #004',
}
#prompt_style = style_from_pygments(TangoStyle, {
prompt_style = style_from_pygments(PromptPygStyle, {
Token.Text: '#888888',
})
class Completer(prompt_toolkit.completion.Completer):
def __init__(self, cmd):
prompt_toolkit.completion.Completer.__init__(self)
self.cmd = cmd
def get_completions(self, document, complete_event):
this_word = document.get_word_before_cursor()
start_of_line = document.current_line_before_cursor.lstrip()
if this_word == start_of_line:
for i in self.cmd.completenames(this_word):
# Other useful completion parameters:
# display=<string> - use different text in popup list
# display_meta=<string> - show additional info in popup
def __init__(self, debugger):
self._filename = None
self.sources = {}
self.debugger = debugger
self.debugger.events.on_stop += self.on_stop
self.current_address_margin = CurrentAddressMargin()
kb = KeyBindings()
self.locals_processor = DisplayVariablesProcessor()
self.source_buffer = Buffer(multiline=True)
self.bar_buffer = Buffer(multiline=True)
self.register_buffer = Buffer(multiline=True)
self.logs_buffer = Buffer(multiline=True)
@kb.add(Keys.F10, eager=True)
def quit_(event):
event.app.exit()
@kb.add(Keys.F8)
def clear_breakpoint_(event):
if self.has_source():
filename, row = self.get_current_location()
self.debugger.clear_breakpoint(filename, row)
@kb.add(Keys.F7)
def set_breakpoint_(event):
if self.has_source():
filename, row = self.get_current_location()
self.debugger.set_breakpoint(filename, row)
@kb.add(Keys.F6)
def step_(event):
self.debugger.step()
@kb.add(Keys.F5)
def run_(event):
self.debugger.run()
@kb.add(Keys.F4)
def stop_(event):
self.debugger.stop()
@kb.add(Keys.PageUp)
def scroll_up_(event):
self.source_buffer.cursor_up(count=15)
@kb.add(Keys.PageDown)
def scroll_down_(event):
self.source_buffer.cursor_down(count=15)
src_lexer = PygmentsLexer(CLexer)
source_code_window = Window(
content=BufferControl(
buffer=self.source_buffer,
lexer=src_lexer,
input_processors=[self.locals_processor],
),
left_margins=[self.current_address_margin,
NumberredMargin()],
right_margins=[ScrollbarMargin(display_arrows=True)],
cursorline=True,
)
register_window = Window(
content=BufferControl(buffer=self.register_buffer), width=20)
title_text = "Welcome to the ppci debugger version {}".format(
ppci_version)
help_text = ("F4=stop F5=run F6=step F7=set breakpoint" +
" F8=clear breakpoint F10=exit")
# Application layout:
layout = HSplit([
Window(content=FormattedTextControl(text=title_text), height=1),
VSplit([
HSplit([
Frame(body=source_code_window),
Window(
content=BufferControl(buffer=self.logs_buffer),
height=2,
),
]),
Frame(body=register_window, title="registers"),
]),
Window(
content=FormattedTextControl(self.get_status_tokens),
height=1,
),
Window(content=FormattedTextControl(help_text), height=1),
])
style = style_from_pygments(get_style_by_name("vim"))
log_handler = MyHandler(self.logs_buffer)
fmt = logging.Formatter(fmt=logformat)
log_handler.setFormatter(fmt)
log_handler.setLevel(logging.DEBUG)
logging.getLogger().setLevel(logging.DEBUG)
logging.getLogger().addHandler(log_handler)
self.application = Application(layout=layout,
style=style,
key_bindings=kb,
full_screen=True)
from prompt_toolkit.shortcuts import prompt
from prompt_toolkit.styles import style_from_pygments
from prompt_toolkit.layout.lexers import PygmentsLexer
from pygments.styles.tango import TangoStyle
from pygments.token import Token
from pygments.lexers import HtmlLexer
our_style = style_from_pygments(
TangoStyle, {
Token.Comment: '#888888 bold',
Token.Keyword: '#ff88ff bold',
}
)
text = prompt('Enter HTML: ', lexer=PygmentsLexer(HtmlLexer), style=our_style)
print('You said: {}'.format(text))
default_style = ''
styles = {
Generic.Inserted: '#88f',
Generic.Heading: 'bold #8f8',
Generic.Error: 'bold #f00',
Text: 'bold #ccf',
# Error is used for, at least, text that doesn't match any token
# (when using a RegexLexer derivitive). As such, it is used for
# text that is being actively typed that doesn't match anything
# *yet*. Should probably leave it as unformatted.
#Error: 'italic #004',
}
#prompt_style = style_from_pygments(TangoStyle, {
prompt_style = style_from_pygments(PromptPygStyle, {
Token.Text: '#888888',
})
class Completer(prompt_toolkit.completion.Completer):
def __init__(self, cmd):
prompt_toolkit.completion.Completer.__init__(self)
self.cmd = cmd
def get_completions(self, document, complete_event):
this_word = document.get_word_before_cursor()
start_of_line = document.current_line_before_cursor.lstrip()
if this_word == start_of_line:
for i in self.cmd.completenames(this_word):
# Other useful completion parameters:
# display=<string> - use different text in popup list
# display_meta=<string> - show additional info in popup
def app_initialize(self, mp):
if sys.platform.startswith('win'):
encoding = api.encoding()
callbacks.ENCODING = encoding
if not interface.get_option("rice.suppress_reticulate_message", False):
interface.reticulate_set_message(RETICULATE_MESSAGE)
if interface.get_option("rice.editing_mode", "emacs") in ["vim", "vi"]:
mp.app.editing_mode = EditingMode.VI
else:
mp.app.editing_mode = EditingMode.EMACS
color_scheme = interface.get_option("rice.color_scheme", "native")
mp.style = style_from_pygments(get_style_by_name(color_scheme))
mp.app.auto_match = interface.get_option("rice.auto_match", False)
mp.app.auto_indentation = interface.get_option("rice.auto_indentation",
True)
mp.app.tab_size = int(interface.get_option("rice.tab_size", 4))
mp.complete_while_typing = interface.get_option(
"rice.complete_while_typing", True)
mp.history_search_no_duplicates = interface.get_option(
"rice.history_search_no_duplicates", False)
mp.insert_new_line = interface.get_option("rice.insert_new_line", True)
prompt = interface.get_option("rice.prompt", None)
if prompt:
mp.set_prompt_mode_message("r", ANSI(prompt))
else:
sys_prompt = interface.get_option("prompt")
if sys_prompt == "> ":
prompt = PROMPT
else:
prompt = sys_prompt
mp.default_prompt = prompt
mp.set_prompt_mode_message("r", ANSI(prompt))
interface.set_option("prompt", prompt)
shell_prompt = interface.get_option("rice.shell_prompt", SHELL_PROMPT)
mp.set_prompt_mode_message("shell", ANSI(shell_prompt))
mp.browse_prompt = interface.get_option("rice.browse_prompt",
BROWSE_PROMPT)
set_width_on_resize = interface.get_option("setWidthOnResize", True)
mp.auto_width = interface.get_option("rice.auto_width",
set_width_on_resize)
if mp.auto_width:
interface.set_option("width", mp.app.output.get_size().columns)
# necessary on windows
interface.set_option("menu.graphics", False)
# enables completion of installed package names
if interface.rcopy(interface.reval("rc.settings('ipck')")) is None:
interface.reval("rc.settings(ipck = TRUE)")
interface.installed_packages()
# print welcome message
sys.stdout.write(interface.r_version())
shell_style = style_from_pygments(
MonokaiStyle,
{
# Commands
Name.Command: "#f2b44f",
Name.SubCommand: "#f2c46f",
Name.InvalidCommand: "bg:#ff0066 #000000",
Name.Select: "#0000ff",
Name.Query: "#d78700",
Name.Key: "#ffffff",
Name.Path: "#fff484",
Name.Help: "#00aa00",
Name.Exit: "#ff0066",
# User input.
Token: "#ff0066",
# Prompt.
Token.Username: "******",
Token.At: "#00aa00",
Token.Colon: "#00aa00",
Token.Pound: "#00aa00",
Token.Tier: "#ff0088",
Token.Path: "#884444 underline",
Token.RPrompt: "bg:#ff0066 #ffffff",
# Toolbar Tokens
Token.Toolbar: "#ffffff bg:#1c1c1c",
Token.TestTier: "#ff0000 bg:#1c1c1c",
Token.ProductionTier: "#ff0000 bg:#1c1c1c",
Token.OfflineNodes: "#ff0000 bg:#1c1c1c",
Token.NodesCount: "#ffffff bg:#1c1c1c",
Token.Spacer: "#ffffff bg:#1c1c1c",
# Alarms
Token.MinorAlarm: "#0000ff bg:#1c1c1c",
Token.MajorAlarm: "#d78700 bg:#1c1c1c",
Token.CriticalAlarm: "#ff0000 bg:#1c1c1c",
Token.AppendFailures: "#0000ff bg:#1c1c1c",
# General
Token.Good: "#ffffff bg:#10c010",
Token.Bad: "#ffffff bg:#c01010",
Token.Info: "#ffffff bg:#1010c0",
Token.Warn: "#000000 bg:#c0c010",
},
)
def main():
if prompt_toolkit.__version__[0:2] != "1.":
from prompt_toolkit import PromptSession
from prompt_toolkit.lexers import PygmentsLexer
from prompt_toolkit.styles.pygments import style_from_pygments_cls
from prompt_toolkit.key_binding import KeyBindings
def key_bindings():
key_binding = KeyBindings()
key_binding.add('enter')(return_handler)
key_binding.add('tab')(tab_handler)
return key_binding
def return_handler(event):
buffer = event.current_buffer
# document = buffer.document
if buffer.text.endswith("\\"):
buffer.text = buffer.text[:-1] + '\n'
else:
buffer.validate_and_handle()
def tab_handler(event):
buffer = event.current_buffer
document = buffer.document
if buffer.auto_suggest:
suggestion = buffer.auto_suggest.get_suggestion(
buffer, document)
if suggestion.text:
buffer.text += suggestion.text
buffer.cursor_position += len(suggestion.text)
def prompt_continuation(width, line_number, is_soft_wrap):
return ' ' * (width - 2) + "… "
style = style_from_pygments_cls(
get_style_by_name(env.get('_debug_read_color_scheme', 'vim')))
session = PromptSession(
message=env.get('_debug_prompt', '$ '),
lexer=PygmentsLexer(BashLexer),
style=style,
key_bindings=key_bindings(),
history=FileHistory(
env.get('JUST_DEBUG_HISTORY',
os.path.expanduser('~/.debug_bash_history')) + '3'),
enable_history_search=True,
multiline=True,
auto_suggest=AutoSuggestFromHistory(),
prompt_continuation=prompt_continuation)
try:
text = session.prompt()
sys.stderr.write(text)
except KeyboardInterrupt:
pass
else:
# from __future__ import unicode_literals
from prompt_toolkit import prompt
from prompt_toolkit.styles import style_from_pygments
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.key_binding.manager import KeyBindingManager
from prompt_toolkit.keys import Keys
manager = KeyBindingManager.for_prompt()
@manager.registry.add_binding(Keys.Enter)
def return_handler(event):
buffer = event.current_buffer
if buffer.text.endswith("\\"):
buffer.text = buffer.text[:-1] + '\n'
else:
buffer.accept_action.validate_and_handle(event.cli, buffer)
@manager.registry.add_binding(Keys.Tab)
def tab_handler(event):
buffer = event.current_buffer
document = buffer.document
if buffer.auto_suggest:
suggestion = buffer.auto_suggest.get_suggestion(
event.cli, buffer, document)
if suggestion.text:
buffer.text += suggestion.text
buffer.cursor_position += len(suggestion.text)
style = style_from_pygments(
get_style_by_name(env.get('_debug_read_color_scheme', 'vim')))
try:
text = prompt(
env.get('_debug_prompt', '$ '),
lexer=PygmentsLexer(BashLexer),
style=style,
key_bindings_registry=manager.registry,
history=FileHistory(
env.get('JUST_DEBUG_HISTORY',
os.path.expanduser('~/.debug_bash_history')) +
'3'),
multiline=True,
auto_suggest=AutoSuggestFromHistory())
sys.stderr.write(text)
except KeyboardInterrupt:
pass
#!/usr/bin/env python
from prompt_toolkit.shortcuts import prompt
from prompt_toolkit.styles import style_from_pygments
from prompt_toolkit.layout.lexers import PygmentsLexer
from pygments.styles.tango import TangoStyle
from pygments.token import Token
from pygments.lexers import HtmlLexer
our_style = style_from_pygments(TangoStyle, {
Token.Comment: '#888888 bold',
Token.Keyword: '#ff88ff bold',
})
text = prompt('Enter HTML: ', lexer=PygmentsLexer(HtmlLexer), style=our_style)
print('You said: {}'.format(text))
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.styles import style_from_pygments
from pygments.lexers import SqlLexer
from pygments.styles.tango import TangoStyle
from pygments.token import Token
custom_style = style_from_pygments(
TangoStyle, {
Token.Comment: '#888888 bold',
Token.Name: '#888888 bold',
Token.Operator: '#888888 bold',
Token.Generic: '#888888 bold',
Token.Other: '#888888 bold',
Token.Number: '#ff9900 bold',
Token.Literal: '#888888 bold',
Token.String: '#00cc00 bold',
Token.Keyword: '#ff00ff bold'
})
from google.api_core.exceptions import BadRequest
from prompt_toolkit import prompt
from prompt_toolkit.token import Token
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.history import FileHistory
from prompt_toolkit.styles import style_from_pygments
from pygments.styles.default import DefaultStyle
from pygments.lexers.sql import PostgresLexer
from bqsh.meta import meta
style = style_from_pygments(DefaultStyle, {
# Prompt tokens.
Token.Project: 'bold',
Token.Dataset: 'bold',
})
def loop(
project, dataset, history_file, completion, multiline, verbose, true_color
):
import ibis
history = FileHistory(history_file)
lexer = PygmentsLexer(PostgresLexer)
con = ibis.bigquery.connect(project, dataset)
while True:
def get_prompt_tokens(cli):
from prompt_toolkit.layout.lexers import PygmentsLexer
from prompt_toolkit.styles import style_from_pygments
from pygments.styles.default import DefaultStyle
from gcloud import storage
import os.path
import click
import shlex
from .lexer import GCSShellLexer
from .path import Path
from .commands import commands_dict, ArgumentError
style = style_from_pygments(
DefaultStyle, {
Token.RPrompt: '#7baec0 bold',
})
class ClientWrapper:
def __init__(self, client):
self.client = client
self.cwd = Path(self, '/')
def __getattr__(self, name):
return getattr(self.client, name)
def get_prompt(path):
return "gs://{} > ".format(path)
