def write_console_ex(buf, otype):
if otype == 0:
if not SUPPRESS_STDOUT:
buf = buf.replace("\r\n", "\n")
sbuf = buf.split("\r")
for i, b in enumerate(sbuf):
print_formatted_text(ANSI(b),
end="",
output=output)
if i < len(sbuf) - 1:
output.write("\r")
output.flush()
TERMINAL_CURSOR_AT_BEGINNING[0] = buf.endswith("\n")
else:
if not SUPPRESS_STDERR:
buf = buf.replace("\r\n", "\n")
sbuf = buf.split("\r")
for i, b in enumerate(sbuf):
print_formatted_text(ANSI(stderr_format.format(b)),
end="",
output=output)
if i < len(sbuf) - 1:
output.write("\r")
output.flush()
TERMINAL_CURSOR_AT_BEGINNING[0] = buf.endswith("\n")
def show_contract_state(self, args):
item = get_arg(args)
if item is not None:
if item.lower() == 'all':
contracts = Blockchain.Default().ShowAllContracts()
print("Contracts: %s" % contracts)
elif item.lower() == 'search':
query = get_arg(args, 1)
if query:
contracts = Blockchain.Default().SearchContracts(query=query)
print("Found %s results for %s" % (len(contracts), query))
for contract in contracts:
bjson = json.dumps(contract.ToJson(), indent=4)
tokens = [("class:number", bjson)]
print_formatted_text(FormattedText(tokens), style=self.token_style)
print('\n')
else:
print("Please specify a search query")
else:
contract = Blockchain.Default().GetContract(item)
if contract is not None:
contract.DetermineIsNEP5()
jsn = contract.ToJson()
bjson = json.dumps(jsn, indent=4)
tokens = [("class:number", bjson)]
print_formatted_text(FormattedText(tokens), style=self.token_style)
print('\n')
else:
print("Please specify a contract")
def patched_handle_exception(self, e):
"""
a new handler for ptpython repl exceptions
it will call excepthook after ommitting all this framework's calls from traceback
for the original, see ptpython.repl.PythonInput._handle_exception
"""
output = self.app.output
t, v, tb = sys.exc_info()
# Required for pdb.post_mortem() to work.
sys.last_type, sys.last_value, sys.last_traceback = t, v, tb
# loop until getting actual traceback
last_stdin_tb = tb
while tb:
if tb.tb_frame.f_code.co_filename == "<stdin>":
last_stdin_tb = tb
tb = tb.tb_next
# except hook does not work as expected
sys.excepthook(t, v, last_stdin_tb)
# just print formatted exception for now
formatted = better_exceptions.format_exception(t, v, last_stdin_tb)
print_formatted_text(ANSI(formatted))
output.write("%s\n" % e)
output.flush()
def show_mem(self):
process = psutil.Process(os.getpid())
total = process.memory_info().rss
totalmb = total / (1024 * 1024)
out = "Total: %s MB\n" % totalmb
out += "Total buffers: %s\n" % StreamManager.TotalBuffers()
print_formatted_text(FormattedText([("class:number", out)]), style=self.token_style)
def show_state(self):
height = Blockchain.Default().Height
headers = Blockchain.Default().HeaderHeight
diff = height - self.start_height
now = datetime.datetime.utcnow()
difftime = now - self.start_dt
mins = difftime / datetime.timedelta(minutes=1)
secs = mins * 60
bpm = 0
tps = 0
if diff > 0 and mins > 0:
bpm = diff / mins
tps = Blockchain.Default().TXProcessed / secs
out = "Progress: %s / %s\n" % (height, headers)
out += "Block-cache length %s\n" % Blockchain.Default().BlockCacheCount
out += "Blocks since program start %s\n" % diff
out += "Time elapsed %s mins\n" % mins
out += "Blocks per min %s \n" % bpm
out += "TPS: %s \n" % tps
tokens = [("class:number", out)]
print_formatted_text(FormattedText(tokens), style=self.token_style)
def patched_handle_exception(self, e):
j = KosmosShellConfig.j
# 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()
output = self.app.output
# Required for pdb.post_mortem() to work.
sys.last_type, sys.last_value, sys.last_traceback = t, v, tb
# loop until getting actual traceback (without internal ptpython part)
last_stdin_tb = tb
while tb:
if tb.tb_frame.f_code.co_filename == "<stdin>":
last_stdin_tb = tb
tb = tb.tb_next
logdict = j.core.tools.log(tb=last_stdin_tb,
level=50,
exception=e,
stdout=False)
formatted_tb = j.core.tools.log2str(logdict, data_show=True, replace=True)
print_formatted_text(ANSI(formatted_tb))
output.write("%s\n" % e)
output.flush()
def show_asset_state(self, args):
item = get_arg(args)
if item is not None:
if item == 'search':
query = get_arg(args, 1)
results = Blockchain.Default().SearchAssetState(query)
print("Found %s results for %s" % (len(results), query))
for asset in results:
bjson = json.dumps(asset.ToJson(), indent=4)
tokens = [("class:number", bjson)]
print_formatted_text(FormattedText(tokens),
style=self.token_style)
print('\n')
return
asset = Blockchain.Default().GetAssetState(item)
if asset is not None:
bjson = json.dumps(asset.ToJson(), indent=4)
tokens = [("class:number", bjson)]
print_formatted_text(FormattedText(tokens),
style=self.token_style)
print('\n')
else:
print("Asset %s not found" % item)
else:
print("Please specify an asset hash")
def get_config_and_history_file(
namespace: argparse.Namespace) -> Tuple[str, str]:
"""
Check which config/history files to use, ensure that the directories for
these files exist, and return the config and history path.
"""
config_dir = os.environ.get(
"PTPYTHON_CONFIG_HOME",
appdirs.user_config_dir("ptpython", "prompt_toolkit"),
)
data_dir = appdirs.user_data_dir("ptpython", "prompt_toolkit")
# Create directories.
for d in (config_dir, data_dir):
pathlib.Path(d).mkdir(parents=True, exist_ok=True)
# Determine config file to be used.
config_file = os.path.join(config_dir, "config.py")
legacy_config_file = os.path.join(os.path.expanduser("~/.ptpython"),
"config.py")
warnings = []
# Config file
if namespace.config_file:
# Override config_file.
config_file = os.path.expanduser(namespace.config_file)
elif os.path.isfile(legacy_config_file):
# Warn about the legacy configuration file.
warnings.append(
HTML(
" <i>~/.ptpython/config.py</i> is deprecated, move your configuration to <i>%s</i>\n"
) % config_file)
config_file = legacy_config_file
# Determine history file to be used.
history_file = os.path.join(data_dir, "history")
legacy_history_file = os.path.join(os.path.expanduser("~/.ptpython"),
"history")
if namespace.history_file:
# Override history_file.
history_file = os.path.expanduser(namespace.history_file)
elif os.path.isfile(legacy_history_file):
# Warn about the legacy history file.
warnings.append(
HTML(
" <i>~/.ptpython/history</i> is deprecated, move your history to <i>%s</i>\n"
) % history_file)
history_file = legacy_history_file
# Print warnings.
if warnings:
print_formatted_text(HTML("<u>Warning:</u>"))
for w in warnings:
print_formatted_text(w)
return config_file, history_file
def stop_timer(timer):
if timer:
timer.stop()
print_formatted_text('Stopped')
timer = None
else:
print_formatted_text('No active timer')
return timer
def show_nodes(self):
if len(NodeLeader.Instance().Peers) > 0:
out = "Total Connected: %s\n" % len(NodeLeader.Instance().Peers)
for peer in NodeLeader.Instance().Peers:
out += "Peer %s - IO: %s\n" % (peer.Name(), peer.IOStats())
print_formatted_text(FormattedText([("class:number", out)]), style=self.token_style)
else:
print("Not connected yet\n")
def show_result(self, result: object) -> None:
"""
Show __repr__ for an `eval` result.
"""
out_prompt = to_formatted_text(self.get_output_prompt())
# If the repr is valid Python code, use the Pygments lexer.
result_repr = repr(result)
try:
compile(result_repr, "", "eval")
except SyntaxError:
formatted_result_repr = to_formatted_text(result_repr)
else:
formatted_result_repr = to_formatted_text(
PygmentsTokens(list(_lex_python_result(result_repr))))
# If __pt_repr__ is present, take this. This can return
# prompt_toolkit formatted text.
if hasattr(result, "__pt_repr__"):
try:
formatted_result_repr = to_formatted_text(
getattr(result, "__pt_repr__")())
if isinstance(formatted_result_repr, list):
formatted_result_repr = FormattedText(
formatted_result_repr)
except:
pass
# Align every line to the prompt.
line_sep = "\n" + " " * fragment_list_width(out_prompt)
indented_repr: StyleAndTextTuples = []
lines = list(split_lines(formatted_result_repr))
for i, fragment in enumerate(lines):
indented_repr.extend(fragment)
# Add indentation separator between lines, not after the last line.
if i != len(lines) - 1:
indented_repr.append(("", line_sep))
# Write output tokens.
if self.enable_syntax_highlighting:
formatted_output = merge_formatted_text(
[out_prompt, indented_repr])
else:
formatted_output = FormattedText(out_prompt + [(
"", fragment_list_to_text(formatted_result_repr))])
print_formatted_text(
formatted_output,
style=self._current_style,
style_transformation=self.style_transformation,
include_default_pygments_style=False,
output=self.app.output,
)
self.app.output.flush()
def list_tasks(api_map, range_):
if range_ == 'today':
today = datetime.date.today()
range_ = [today, today]
elif range_ == 'week':
today = datetime.date.today()
start = today - datetime.timedelta(days=today.weekday())
end = start + datetime.timedelta(days=6)
range_ = [start, end]
elif range_ == 'month':
today = datetime.date.today()
range_ = [
today.replace(day=1),
today.replace(day=1, month=today.month + 1) -
datetime.timedelta(days=1)
]
table = set()
total = 0
for account, api in api_map.items():
records = api.users.time()
me_id = str(api.users.me()['id'])
record_map = {}
record_names = {}
for record in records:
# 2018-06-18 04:44:33
record_date = datetime.datetime.strptime(record['date'],
'%Y-%m-%d').date()
if range_[1] >= record_date >= range_[0]:
total += record['time']
record_id = record['task']['id']
if record_id not in record_map:
record_map[record_id] = TimeRecord(
name=record['task']['name'],
id=record['task']['id'],
time=record['time'])
else:
record_map[record_id] = record_map[record_id]._replace(
time=record_map[record_id].time + record['time'])
for k, task in record_map.items():
task_time = _strfttime(task.time)
row = (account, task.id, '\n'.join(textwrap.wrap(task.name,
50)), task_time)
table.add(row)
table = sorted(table, key=lambda i: i[0])
total_time = _strfttime(total)
table.append(('total', '', 'Total', total_time))
print_formatted_text(
tabulate.tabulate(
table,
['account', 'id', 'name', 'time'],
# floatfmt='.2f',
tablefmt='grid'))
def render(output):
dump = json.dumps(output, indent=4)
tokens = list(json_lexer.get_tokens(dump))
with pager(options="-FRSX") as less:
if is_flat(output):
table = tabulate(*tabularize(output), tablefmt="psql").encode("utf-8")
less.write(table)
else:
print_formatted_text(PygmentsTokens(tokens), style=style, file=less)
def _render_sdl(self, sdl: str) -> None:
desc_doc = pt_document.Document(sdl)
lexer = pt_lexers.PygmentsLexer(eql_pygments.EdgeQLLexer)
formatter = lexer.lex_document(desc_doc)
for line in range(desc_doc.line_count):
pt_shortcuts.print_formatted_text(pt_formatted_text.FormattedText(
formatter(line)),
style=self.style)
print()
def _get_user_input(self):
"""
Display appropriate label and collect user input.
This private method displays the appropriate prompt label
for the field using the appropriate display function
and collect the user input.
Returns
-------
user_input : list or str
A string for fields that accepts a single input
or a list of strings for fields that accept multiple
inputs, e.g., subgroups.
"""
# if we are dealing with a field that accepts multiple inputs
if self.count == 'multiple':
# instantiate a blank list to hold the multiple values
values = []
# show the name of the field as a heading but do not
# ask for input yet
print_formatted_text(HTML(f" <b>{self.label}</b>"))
# ask the user how many of the multiple inputs they
# intend to provide; this must be non-zero
num_entries = prompt(" How many do you want to specify: ",
validator=self._make_integer_validator())
num_entries = int(num_entries)
# display secondary prompts, one for each of the inputs
# with the appropriate completer, validator, and style
for i in range(num_entries):
value = prompt(f" Enter #{i+1}: ",
completer=self.completer,
validator=self.validator,
complete_style=self.complete_style)
# save the value in the list
values.append(value)
# this is what we will return
user_input = values
# if we are dealing with a simple single-input field
else:
# nothing fancy, just display the label, attach
# the appropriate completer, validator, and style,
# and get the user input
user_input = prompt(HTML(f" <b>{self.label}</b>: "),
completer=self.completer,
validator=self.validator,
complete_style=self.complete_style)
return user_input
def print_formatted_text(self,
formatted_text: StyleAndTextTuples,
end: str = "\n") -> None:
print_formatted_text(
FormattedText(formatted_text),
style=self._current_style,
style_transformation=self.style_transformation,
include_default_pygments_style=False,
output=self.app.output,
end=end,
)
def auto_rewrite_input(self, cmd):
"""Overridden from the parent class to use fancy rewriting prompt"""
if not self.show_rewritten_input:
return
tokens = self.prompts.rewrite_prompt_tokens()
if self.pt_app:
print_formatted_text(PygmentsTokens(tokens), end='',
style=self.pt_app.app.style)
print(cmd)
else:
prompt = ''.join(s for t, s in tokens)
print(prompt, cmd, sep='')
def auto_rewrite_input(self, cmd):
"""Overridden from the parent class to use fancy rewriting prompt"""
if not self.show_rewritten_input:
return
tokens = self.prompts.rewrite_prompt_tokens()
if self.pt_app:
print_formatted_text(PygmentsTokens(tokens), end='',
style=self.pt_app.app.style)
print(cmd)
else:
prompt = ''.join(s for t, s in tokens)
print(prompt, cmd, sep='')
def apply_validators(self):
validators = self._question.get('validators', [])
error_messages = []
for validator in validators:
try:
validator.validate(self.get_value(), self._context)
except ValidationError as ve:
error_messages.append(ve.message)
if self._mode == Mode.PROMPT:
print_formatted_text(
FormattedText([('class:prompt.error', ve.message)]),
style=get_theme_manager().get_current_style())
return error_messages
def _handle_exception(self, e: BaseException) -> None:
output = self.app.output
tokens = self._format_exception_output(e)
print_formatted_text(
tokens,
style=self._current_style,
style_transformation=self.style_transformation,
include_default_pygments_style=False,
output=output,
)
output.write("%s\n" % e)
output.flush()
def show_account_state(self, args):
item = get_arg(args)
if item is not None:
account = Blockchain.Default().GetAccountState(item, print_all_accounts=True)
if account is not None:
bjson = json.dumps(account.ToJson(), indent=4)
tokens = [("class:number", bjson)]
print_formatted_text(FormattedText(tokens), style=self.token_style)
print('\n')
else:
print("Account %s not found" % item)
else:
print("Please specify an account address")
def write_console_ex(buf, otype):
if otype == 0:
if sys.stdout:
sys.stdout.write(buf)
sys.stdout.flush()
TERMINAL_CURSOR_AT_BEGINNING[0] = buf.endswith("\n")
else:
if sys.stderr:
buf = buf.replace("\r\n", "\n")
sbuf = buf.split("\r")
for i, b in enumerate(sbuf):
print_formatted_text(ANSI(stderr_format.format(b)), end="", file=sys.stderr)
if i < len(sbuf) - 1:
sys.stderr.write("\r")
sys.stderr.flush()
TERMINAL_CURSOR_AT_BEGINNING[0] = buf.endswith("\n")
def _handle_exception(self, e):
output = self.app.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()
# Required for pdb.post_mortem() to work.
sys.last_type, sys.last_value, sys.last_traceback = t, v, tb
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.)
if self.enable_syntax_highlighting:
tokens = list(_lex_python_traceback(tb))
else:
tokens = [(Token, tb)]
print_formatted_text(PygmentsTokens(tokens),
style=self._current_style,
style_transformation=self.style_transformation,
include_default_pygments_style=False)
output.write('%s\n' % e)
output.flush()
def show_tx(self, args):
if len(args):
try:
txid = UInt256.ParseString(get_arg(args))
tx, height = Blockchain.Default().GetTransaction(txid)
if height > -1:
jsn = tx.ToJson()
jsn['height'] = height
jsn['unspents'] = [uns.ToJson(tx.outputs.index(uns)) for uns in
Blockchain.Default().GetAllUnspent(txid)]
tokens = [("class:command", json.dumps(jsn, indent=4))]
print_formatted_text(FormattedText(tokens), style=self.token_style)
print('\n')
except Exception as e:
print("Could not find transaction from args: %s (%s)" % (e, args))
else:
print("Please specify a TX hash")
def _handle_exception(self, e):
output = self.app.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()
# Required for pdb.post_mortem() to work.
sys.last_type, sys.last_value, sys.last_traceback = t, v, tb
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.)
if self.enable_syntax_highlighting:
tokens = list(_lex_python_traceback(tb))
else:
tokens = [(Token, tb)]
print_formatted_text(
PygmentsTokens(tokens), style=self._current_style,
style_transformation=self.style_transformation,
include_default_pygments_style=False)
output.write('%s\n' % e)
output.flush()
def write_output_prompt(self):
sys.stdout.write(self.shell.separate_out)
# If we're not displaying a prompt, it effectively ends with a newline,
# because the output will be left-aligned.
self.prompt_end_newline = True
if self.do_full_cache:
tokens = self.shell.prompts.out_prompt_tokens()
prompt_txt = ''.join(s for t, s in tokens)
if prompt_txt and not prompt_txt.endswith('\n'):
# Ask for a newline before multiline output
self.prompt_end_newline = False
if self.shell.pt_app:
print_formatted_text(PygmentsTokens(tokens),
style=self.shell.pt_app.app.style, end='',
)
else:
sys.stdout.write(prompt_txt)
def write_output_prompt(self):
sys.stdout.write(self.shell.separate_out)
# If we're not displaying a prompt, it effectively ends with a newline,
# because the output will be left-aligned.
self.prompt_end_newline = True
if self.do_full_cache:
tokens = self.shell.prompts.out_prompt_tokens()
prompt_txt = ''.join(s for t, s in tokens)
if prompt_txt and not prompt_txt.endswith('\n'):
# Ask for a newline before multiline output
self.prompt_end_newline = False
if self.shell.pt_app:
print_formatted_text(PygmentsTokens(tokens),
style=self.shell.pt_app.app.style, end='',
)
else:
sys.stdout.write(prompt_txt)
def _handle_exception(self, e: BaseException) -> None:
output = self.app.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()
# Required for pdb.post_mortem() to work.
sys.last_type, sys.last_value, sys.last_traceback = t, v, tb
tblist = list(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_str = "".join(l)
# Format exception and write to output.
# (We use the default style. Most other styles result
# in unreadable colors for the traceback.)
if self.enable_syntax_highlighting:
tokens = list(_lex_python_traceback(tb_str))
else:
tokens = [(Token, tb_str)]
print_formatted_text(
PygmentsTokens(tokens),
style=self._current_style,
style_transformation=self.style_transformation,
include_default_pygments_style=False,
output=output,
)
output.write("%s\n" % e)
output.flush()
def show_block(self, args):
item = get_arg(args)
txarg = get_arg(args, 1)
if item is not None:
block = Blockchain.Default().GetBlock(item)
if block is not None:
bjson = json.dumps(block.ToJson(), indent=4)
tokens = [("class:number", bjson)]
print_formatted_text(FormattedText(tokens), style=self.token_style)
print('\n')
if txarg and 'tx' in txarg:
for tx in block.FullTransactions:
print(json.dumps(tx.ToJson(), indent=4))
else:
print("Could not locate block %s" % item)
else:
print("please specify a block")
def resolve_file_conversion(remote_file: GoogleDriveFile) -> str:
"""
A function to take in a remote file and return to the caller a string that represents the file extension to use
for this file. This exists to let users who may not know what conversion are available see all options that are
available to them given a document type so they can download the file as the one best suited to their needs.
Parameters:
remote_file (GoogleDriveFile): The remote file who we are attempting to get the conversion for
Returns:
conversion_opts[user_input] (str): The file extension we are converting this file to
"""
while 1:
# Print the helpful prompt on what the user is choosing and cache the supported conversions list for this
# file
print_formatted_text(ANSI(f"\x1b[36mWhat file type would you like to convert \"{remote_file['title']}\" to?"))
conversion_opts = [ext for ext, link in SUPPORTED_FILE_TYPES.items() if link in remote_file['exportLinks']]
# Print out all of the possible conversion's for this document and their associated number
for choice, conversion in enumerate(conversion_opts):
print_formatted_text(f"[{choice + 1}]: {conversion}")
try:
# Prompt the user for their choice of the file types printed out above
user_input = int(prompt(ANSI(f'\x1b[36mChoose [1-{len(conversion_opts)}]: '))) - 1
# If the user input a valid index then return the conversion extension they desire
if 0 <= user_input < len(conversion_opts):
return conversion_opts[user_input]
# If the user input a non integer cast-able value then inform them to use the numbers
except ValueError:
print_formatted_text(ANSI('\x1b[31mPlease input the integer that corresponds to your desired file type'))
def resolve_mnemonic_conflict(matching_filenames: List[GoogleDriveFile]) -> GoogleDriveFile:
"""
A function to ask the user to resolve any mnemonic conflicts that can arise because of how Google Drive
works. Since Google Drive has display names that are not unique and since we want to use traditional file
pathing as much as possible it is possible that a filename may correspond to many different files. In that case
we need to ask the user which one they meant to reference with their query
Parameters:
matching_filenames (List[GoogleDriveFile]): A list of all google drive files matched the query by the user
Returns:
file_ids[response] (GoogleDriveFile): The GoogleDriveFile whose ID was entered by the user when prompted
"""
# Cache a dictionary linking all file ids to their corresponding file objects
file_ids = {file['id']: file for file in matching_filenames}
while 1:
# Let the user know what is going wrong before anything else
print_formatted_text(ANSI("\x1b[31mThere are multiple files with the same filename given!\n"))
# Until the user provides the info we want keep printing the matching files
for file in matching_filenames:
pretty_date = file['modifiedDate'][:file['modifiedDate'].index('.')].replace('T', ' ')
print_formatted_text(ANSI(f"\x1b[36mDisplay Name: \x1b[37m{file['title']} \x1b[36mLast Modified: "
f"\x1b[37m{pretty_date} \x1b[36mFile ID: \x1b[37m{file['id']}"))
# Newline for terminal readability and prompt the user to resolve the conflict
print_formatted_text("")
response = prompt(ANSI('\x1b[31mPlease copy/paste the ID of the file to which you were referring: '))
# If the user's response is a valid key then return the associated file
if response in file_ids.keys():
return file_ids[response]
def _execute(self, line):
"""
Evaluate the line and print the result.
"""
output = self.app.output
# WORKAROUND: Due to a bug in Jedi, the current directory is removed
# from sys.path. See: https://github.com/davidhalter/jedi/issues/1148
if '' not in sys.path:
sys.path.insert(0, '')
def compile_with_flags(code, mode):
" Compile code with the right compiler flags. "
return compile(code, '<stdin>', mode,
flags=self.get_compiler_flags(),
dont_inherit=True)
if line.lstrip().startswith('\x1a'):
# When the input starts with Ctrl-Z, quit the REPL.
self.app.exit()
elif line.lstrip().startswith('!'):
# Run as shell command
os.system(line[1:])
else:
# Try eval first
try:
code = compile_with_flags(line, 'eval')
result = eval(code, self.get_globals(), self.get_locals())
locals = self.get_locals()
locals['_'] = locals['_%i' % self.current_statement_index] = result
if result is not None:
out_prompt = self.get_output_prompt()
try:
result_str = '%r\n' % (result, )
except UnicodeDecodeError:
# In Python 2: `__repr__` should return a bytestring,
# so to put it in a unicode context could raise an
# exception that the 'ascii' codec can't decode certain
# characters. Decode as utf-8 in that case.
result_str = '%s\n' % repr(result).decode('utf-8')
# Align every line to the first one.
line_sep = '\n' + ' ' * fragment_list_width(out_prompt)
result_str = line_sep.join(result_str.splitlines()) + '\n'
# Write output tokens.
if self.enable_syntax_highlighting:
formatted_output = merge_formatted_text([
out_prompt,
PygmentsTokens(list(_lex_python_result(result_str))),
])
else:
formatted_output = FormattedText(
out_prompt + [('', result_str)])
print_formatted_text(
formatted_output, style=self._current_style,
style_transformation=self.style_transformation,
include_default_pygments_style=False)
# If not a valid `eval` expression, run using `exec` instead.
except SyntaxError:
code = compile_with_flags(line, 'exec')
six.exec_(code, self.get_globals(), self.get_locals())
output.flush()
def print_remote_prompt(self, ec=None):
tokens = self.get_remote_prompt_tokens() + self.get_prompt_tokens(
ec=ec)
print_formatted_text(PygmentsTokens(tokens),
end="",
style=self.pt_cli.app.style)
def print_out_prompt(self):
tokens = self.get_out_prompt_tokens()
print_formatted_text(PygmentsTokens(tokens), end='',
style = self.pt_cli.app.style)
def patched_execute(self, line):
"""
Evaluate the line and print the result.
"""
output = self.app.output
# WORKAROUND: Due to a bug in Jedi, the current directory is removed
# from sys.path. See: https://github.com/davidhalter/jedi/issues/1148
if "" not in sys.path:
sys.path.insert(0, "")
def compile_with_flags(code, mode):
" Compile code with the right compiler flags. "
return compile(code, "<stdin>", mode, flags=self.get_compiler_flags(), dont_inherit=True)
if line.lstrip().startswith("\x1a"):
# When the input starts with Ctrl-Z, quit the REPL.
self.app.exit()
elif line.lstrip().startswith("!"):
# Run as shell command
os.system(line[1:])
else:
# Try eval first
try:
code = compile_with_flags(line, "eval")
result = eval(code, self.get_globals(), self.get_locals())
locals = self.get_locals()
locals["_"] = locals["_%i" % self.current_statement_index] = result
if result is not None:
out_prompt = self.get_output_prompt()
try:
result_str = "%r\n" % (result,)
except UnicodeDecodeError:
# In Python 2: `__repr__` should return a bytestring,
# so to put it in a unicode context could raise an
# exception that the 'ascii' codec can't decode certain
# characters. Decode as utf-8 in that case.
result_str = "%s\n" % repr(result).decode("utf-8")
# Align every line to the first one.
line_sep = "\n" + " " * fragment_list_width(out_prompt)
result_str = line_sep.join(result_str.splitlines()) + "\n"
# Support ansi formatting (removed syntax higlighting)
ansi_formatted = ANSI(result_str)._formatted_text
formatted_output = merge_formatted_text([FormattedText(out_prompt) + ansi_formatted])
print_formatted_text(
formatted_output,
style=self._current_style,
style_transformation=self.style_transformation,
include_default_pygments_style=False,
)
# If not a valid `eval` expression, run using `exec` instead.
except SyntaxError:
code = compile_with_flags(line, "exec")
six.exec_(code, self.get_globals(), self.get_locals())
output.flush()
