def test_render_nested_pairs():
text = [
b"peak.allocated",
10160336,
b"lua.caches",
0,
b"db.0",
[b"overhead.hashtable.main", 648, b"overhead.hashtable.expires", 32],
b"db.1",
[b"overhead.hashtable.main", 112, b"overhead.hashtable.expires", 32],
b"fragmentation",
b"0.062980629503726959",
b"fragmentation.bytes",
-9445680,
]
assert renders.OutputRender.render_raw(text) == (
b"peak.allocated\n10160336\nlua.caches\n0\ndb.0\noverhead.hashtable.main\n64"
b"8\noverhead.hashtable.expires\n32\ndb.1\noverhead.hashtable.main\n112\nove"
b"rhead.hashtable.expires\n32\nfragmentation\n0.062980629503726959\nfragmentat"
b"ion.bytes\n-9445680")
assert renders.OutputRender.render_nested_pair(text) == FormattedText([
("class:string", "peak.allocated: "),
("class:value", "10160336"),
("", "\n"),
("class:string", "lua.caches: "),
("class:value", "0"),
("", "\n"),
("class:string", "db.0: "),
("", "\n"),
("class:string", " overhead.hashtable.main: "),
("class:value", "648"),
("", "\n"),
("class:string", " overhead.hashtable.expires: "),
("class:value", "32"),
("", "\n"),
("class:string", "db.1: "),
("", "\n"),
("class:string", " overhead.hashtable.main: "),
("class:value", "112"),
("", "\n"),
("class:string", " overhead.hashtable.expires: "),
("class:value", "32"),
("", "\n"),
("class:string", "fragmentation: "),
("class:value", "0.062980629503726959"),
("", "\n"),
("class:string", "fragmentation.bytes: "),
("class:value", "-9445680"),
])
def test_render_list_or_string():
config.raw = False
assert renders.OutputRender.render_list_or_string("") == '""'
assert renders.OutputRender.render_list_or_string("foo") == '"foo"'
assert renders.OutputRender.render_list_or_string(
[b"foo", b"bar"]) == FormattedText([
("", "1)"),
("", " "),
("class:string", '"foo"'),
("", "\n"),
("", "2)"),
("", " "),
("class:string", '"bar"'),
])
def show_help(extra= None):
help_command = '''
Core commands
=============
Command Description
------- -----------
help Help menu
load <module> Load module
modules [category] List all modules or a certain category
find <info> Search modules with concret info
exit|quit Exit application
banner Show banner
export Save global options
import Load global options (previously exported)
tasks <show/kill> [id] Show tasks running or kill a task
theme dark|light|default Change the theme of the tool
# <command> Grant terminal commands
'''
help_command += '''
Module commands
===============
Command Description
------- -----------
set <option> <value> Set value for module's option
unset <option> Unset value for module's option
run Run module
back Unload module
show [options|info] Show either options or info
global <option> <value> Set global option
'''
if extra:
help_command += f"""
Additional feature
==================
Command Description
------- -----------"""
for k, v in extra.items():
if len(k) > 26:
k = k[:22] + "..."
help_command += f"""
{str(k).ljust(26)} {v}"""
print("\n")
text = FormattedText([(f'{ColorSelected().theme.text}', help_command)])
print_formatted_text(text)
def test_timestamp_completer_datetime_format_time_completion():
c = TimestampCompleter()
fake_document = MagicMock()
fake_document.text = fake_document.text_before_cursor = "2020-02-07"
completions = list(c.get_completions(fake_document, None))
assert completions == [
Completion(
text="1581033600000",
start_position=-10,
display=FormattedText([("", "1581033600000")]),
display_meta="2020-02-07T00:00:00+00:00",
)
]
def error(self, source, header_text=''):
if source is None:
return
if not self.app.batch_mode:
self._tee_print(
merge_formatted_text([
HTML('<ansired>--- </ansired>').formatted_text,
FormattedText([(PeekStyle.styles[TipsMinor], header_text)])
]),
plain_source=f'--- {header_text}')
if isinstance(source, FormattedText):
self._tee_print(source)
else:
self._tee_print(source, plain_source=source)
def command_syntax(command, command_info):
"""
Get command syntax based on redis-doc/commands.json
:param command: Command name in uppercase
:param command_info: dict loaded from commands.json, only for
this command.
"""
comamnd_group = command_info["group"]
bottoms = [
("class:bottom-toolbar.group", f"({comamnd_group}) "),
("class:bottom-toolbar.command", f"{command}"),
] # final display FormattedText
if command_info.get("arguments"):
for argument in command_info["arguments"]:
if argument.get("command"):
# command [
bottoms.append(
(f"class:bottom-toolbar.command", " [" + argument["command"])
)
if argument.get("enum"):
enums = "|".join(argument["enum"])
bottoms.append((f"class:bottom-toolbar.const", f" [{enums}]"))
elif argument.get("name"):
bottoms.extend(
parse_argument_to_formatted_text(
argument["name"], argument["type"], argument.get("optional")
)
)
# ]
bottoms.append((f"class:bottom-toolbar.command", "]"))
elif argument.get("enum"):
enums = "|".join(argument["enum"])
bottoms.append((f"class:bottom-toolbar.const", f" [{enums}]"))
else:
bottoms.extend(
parse_argument_to_formatted_text(
argument["name"], argument["type"], argument.get("optional")
)
)
if "since" in command_info:
since = command_info["since"]
bottoms.append(("class:bottom-toolbar.since", f" since: {since}"))
if "complexity" in command_info:
complexity = command_info["complexity"]
bottoms.append(("class:bottom-toolbar.complexity", f" complexity:{complexity}"))
return FormattedText(bottoms)
def main():
tokens = FormattedText([("fg:" + name, name + " ")
for name in NAMED_COLORS])
print(HTML("\n<u>Named colors, using 16 color output.</u>"))
print("(Note that it doesn't really make sense to use named colors ")
print("with only 16 color output.)")
print(tokens, color_depth=ColorDepth.DEPTH_4_BIT)
print(HTML("\n<u>Named colors, use 256 colors.</u>"))
print(tokens)
print(HTML("\n<u>Named colors, using True color output.</u>"))
print(tokens, color_depth=ColorDepth.TRUE_COLOR)
def test_newbie_mode_complete_with_meta_dict():
config.newbie_mode = True
session = prompt_session()
fake_document = MagicMock()
fake_document.text_before_cursor = "get"
completions = list(session.completer.get_completions(fake_document, None))
assert completions[:2] == [
Completion(
text="get",
start_position=-3,
display=FormattedText([("", "get")]),
display_meta=FormattedText([("", "Get the value of a key")]),
),
Completion(
text="getset",
start_position=-3,
display=FormattedText([("", "getset")]),
display_meta=FormattedText(
[("", "Set the string value of a key and return its old value")]
),
),
]
def test_render_unixtime_config_raw():
# fake the timezone and reload
os.environ["TZ"] = "Asia/Shanghai"
time.tzset()
rendered = renders.OutputRender.render_unixtime(1570469891)
assert rendered == FormattedText([
("class:type", "(integer) "),
("", "1570469891"),
("", "\n"),
("class:type", "(local time)"),
("", " "),
("", "2019-10-08 01:38:11"),
])
def main():
tokens = FormattedText([('fg:' + name, name + ' ')
for name in NAMED_COLORS])
print(HTML('\n<u>Named colors, using 16 color output.</u>'))
print('(Note that it doesn\'t really make sense to use named colors ')
print('with only 16 color output.)')
print(tokens, color_depth=ColorDepth.DEPTH_4_BIT)
print(HTML('\n<u>Named colors, use 256 colors.</u>'))
print(tokens)
print(HTML('\n<u>Named colors, using True color output.</u>'))
print(tokens, color_depth=ColorDepth.TRUE_COLOR)
def test_render_time():
value = [b"1571305643", b"765481"]
assert renders.OutputRender.render_time(value) == FormattedText([
("class:type", "(unix timestamp) "),
("", "1571305643"),
("", "\n"),
("class:type", "(millisecond) "),
("", "765481"),
("", "\n"),
("class:type", "(convert to local timezone) "),
("", "2019-10-17 17:47:23.765481"),
])
assert renders.OutputRender.render_raw(value) == b"1571305643\n765481"
def render_list(byte_items, str_items, style=None):
if config.raw:
return b"\n".join(byte_items)
index_width = len(str(len(str_items)))
rendered = []
for index, item in enumerate(str_items):
index_const_width = f"{index+1:{index_width}})"
rendered.append(("", index_const_width))
if index + 1 < len(str_items):
text = f" {item}\n"
else: # last one don't have \n
text = f" {item}"
rendered.append((style, text))
return FormattedText(rendered)
def _internal_prompt_print(self, *args, **kwargs):
kwargs['sep'] = kwargs.pop('sep', ' ')
kwargs['end'] = kwargs.pop('end', '\n')
kwargs['file'] = kwargs.pop('file', sys.stdout)
kwargs['style'] = token_style
frags = []
for a in args:
if isinstance(a, FormattedText):
frags.append(a)
else:
frags.append(FormattedText([("class:command", str(a))]))
print_formatted_text(*frags, **kwargs)
def test_peek_list_fetch_all(iredis_client, clean_redis):
clean_redis.lpush("mylist", *[f"hello-{index}" for index in range(5)])
peek_result = list(iredis_client.do_peek("mylist"))
assert peek_result == [
FormattedText(
[
("class:dockey", "key: "),
("", "list (quicklist) mem: 176 bytes, ttl: -1"),
]
),
FormattedText([("class:dockey", "llen: "), ("", "5")]),
FormattedText([("class:dockey", "elements: ")]),
FormattedText(
[
("", "1)"),
("", " "),
("class:string", '"hello-4"'),
("", "\n"),
("", "2)"),
("", " "),
("class:string", '"hello-3"'),
("", "\n"),
("", "3)"),
("", " "),
("class:string", '"hello-2"'),
("", "\n"),
("", "4)"),
("", " "),
("class:string", '"hello-1"'),
("", "\n"),
("", "5)"),
("", " "),
("class:string", '"hello-0"'),
]
),
]
def test_peek_hash_fetch_all(iredis_client, clean_redis):
for key, value in zip(
[f"hello-{index}" for index in range(3)], [f"hi-{index}" for index in range(3)]
):
clean_redis.hset("myhash", key, value)
peek_result = list(iredis_client.do_peek("myhash"))
assert peek_result == [
FormattedText(
[("class:dockey", "key: "), ("", "hash (ziplist) mem: 104 bytes, ttl: -1")]
),
FormattedText([("class:dockey", "hlen: "), ("", "3")]),
FormattedText([("class:dockey", "fields: ")]),
FormattedText(
[
("", "1)"),
("", " "),
("class:field", '"hello-0"'),
("", "\n"),
("", " "),
("class:string", '"hi-0"'),
("", "\n"),
("", "2)"),
("", " "),
("class:field", '"hello-1"'),
("", "\n"),
("", " "),
("class:string", '"hi-1"'),
("", "\n"),
("", "3)"),
("", " "),
("class:field", '"hello-2"'),
("", "\n"),
("", " "),
("class:string", '"hi-2"'),
]
),
]
def get_clock(self):
"""make clock text"""
if self.sec:
clock = np.array([[background_char] * 124] * 14)
else:
clock = np.array([[background_char] * 80] * 14)
now = dt.now()
clock[1:13, 1:16] = self.get_number(now.hour // 10)
clock[1:13, 20:35] = self.get_number(now.hour % 10)
clock[1:13, 36:43] = self.get_coron()
clock[1:13, 45:60] = self.get_number(now.minute // 10)
clock[1:13, 64:79] = self.get_number(now.minute % 10)
if self.sec:
clock[1:13, 80:87] = self.get_coron()
clock[1:13, 89:104] = self.get_number(now.second // 10)
clock[1:13, 108:123] = self.get_number(now.second % 10)
t = '\n'.join([''.join(x) for x in clock])
# 5 min bofore, 15 min after events
if self.color:
b_event = []
a_event = []
for x in self.gcalender.events:
if x['month'] == now.month and x['day'] == now.day and x[
'hour'] is not None:
d = (x['hour'] * 60 + x['minute']) - (now.hour * 60 +
now.minute)
if d <= 5 and d > 0:
b_event.append(x)
if d <= 0 and d >= -15:
a_event.append(x)
if b_event:
return FormattedText([('#FF0000', t)])
if a_event:
return FormattedText([('#008000', t)])
return t
def showwarning(message:Warning, category, filename, lineno, file=None, line=None):
if category == UserWarning:
if session.has_instance():
ldi, tokens = session.get_vm().pc
print_error_formatted(
message, LineDebugInfo(ldi.filename, ldi.lineid, ldi.token_pos[max(-len(tokens)-1, -len(ldi.token_pos))]),
session.is_interactive(), extra_indent=6 if session.is_interactive() else 0)
else:
print_formatted_text(FormattedText([
('magenta', 'Warning: '),
('', str(message))
]))
else:
return showwarning_default(message, category, filename, lineno, file, line)
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 render_time(value):
unix_timestamp, millisecond = value[0].decode(), value[1].decode()
explained_date = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime(int(unix_timestamp)))
rendered = [
("class:type", "(unix timestamp) "),
("", unix_timestamp),
NEWLINE_TUPLE,
("class:type", "(millisecond) "),
("", millisecond),
NEWLINE_TUPLE,
("class:type", "(convert to local timezone) "),
("", f"{explained_date}.{millisecond}"),
]
return FormattedText(rendered)
def _CommandRun(command):
line = FormattedText([('', '['), ('#ff0000', 'Out'), ('', ']')])
process = subprocess.Popen(shlex.split(command), stdout=subprocess.PIPE)
while True:
output = process.stdout.readline()
if output == b'' and process.poll() is not None:
break
if output:
print_formatted_text(line, end="")
print(">> " + output.strip().decode('utf-8'))
rc = process.poll()
return rc
def render_list(text, style="class:string"):
"""
Render callback for redis Array Reply
Note: Cloud be null in it.
"""
str_items = []
for item in text:
if item is None:
str_items.append(None)
else:
str_item = ensure_str(item)
double_quoted = double_quotes(str_item)
str_items.append(double_quoted)
rendered = _render_list(text, str_items, style)
return FormattedText(rendered)
def test_peek_zset_fetch_part(iredis_client, clean_redis):
clean_redis.zadd(
"myzset",
dict(zip([f"hello-{index}" for index in range(40)], range(40))))
peek_result = list(iredis_client.do_peek("myzset"))
assert peek_result[0][0:8] == FormattedText([
("class:dockey", "key: "),
("", "zset (ziplist) mem: 556 bytes, ttl: -1"),
("", "\n"),
("class:dockey", "zcount: "),
("", "40"),
("", "\n"),
("class:dockey", "members (first 40): "),
("", "\n"),
])
def info(self, source, header_text=''):
if source is None:
return
if not self.app.batch_mode:
self._tee_print(
FormattedText([
(PeekStyle.styles[Heading], '=== '),
(PeekStyle.styles[TipsMinor], header_text)
]),
plain_source=f'=== {header_text}')
if isinstance(source, FormattedText):
self._tee_print(source)
else:
source, plain_source = self._try_jsonify(source) # TODO: try more types
self._tee_print(source, plain_source=plain_source)
def test_newbie_mode_complete_with_meta_dict_command_is_lowercase():
fake_document = MagicMock()
fake_document.text_before_cursor = fake_document.text = "geor"
completer = IRedisCompleter(hint=True)
completions = list(completer.get_completions(fake_document, None))
assert sorted([completion.display_meta for completion in completions]) == [
FormattedText(
[
(
"",
"Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member", # noqa
)
]
),
FormattedText(
[
(
"",
"Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point", # noqa
)
]
),
]
async def input_loop(self) -> None:
while True:
with patch_stdout():
prompt_task = asyncio.create_task(
self.session.prompt_async(
FormattedText([('#ffffff', '> ')])))
await asyncio.wait({prompt_task, self.shutdown},
return_when=FIRST_COMPLETED)
if self.shutdown.done():
break
if prompt_task.done():
text = prompt_task.result()
self.publish(TextInput(text=text))
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 test_group_completer():
fake_document = MagicMock()
previous_commands = [
"xgroup create abc world 123", "xgroup setid abc hello 123"
]
fake_document.text = fake_document.text_before_cursor = "XGROUP DESTROY key "
completer = IRedisCompleter()
for command in previous_commands:
completer.update_completer_for_input(command)
completions = list(completer.get_completions(fake_document, None))
assert completions == [
Completion(
text="hello",
start_position=0,
display=FormattedText([("", "hello")]),
display_meta=FormattedText([("", "")]),
),
Completion(
text="world",
start_position=0,
display=FormattedText([("", "world")]),
display_meta=FormattedText([("", "")]),
),
]
def test_peek_string(iredis_client, clean_redis):
clean_redis.set("foo", "bar")
peek_result = list(iredis_client.do_peek("foo"))
assert peek_result == [
FormattedText([
("class:dockey", "key: "),
("", "string (embstr) mem: 50 bytes, ttl: -1"),
("", "\n"),
("class:dockey", "strlen: "),
("", "3"),
("", "\n"),
("class:dockey", "value: "),
("", '"bar"'),
])
]
def test_peek_zset_fetch_all(iredis_client, clean_redis):
clean_redis.zadd(
"myzset", dict(zip([f"hello-{index}" for index in range(3)],
range(3))))
peek_result = list(iredis_client.do_peek("myzset"))
assert peek_result[0][0:9] == FormattedText([
("class:dockey", "key: "),
("", "zset (ziplist) mem: 92 bytes, ttl: -1"),
("", "\n"),
("class:dockey", "zcount: "),
("", "3"),
("", "\n"),
("class:dockey", "members: "),
("", "\n"),
("", "1)"),
])
def prompt(self) -> FormattedText:
"""Generate the Command Prompt as a FormattedText. This format is mostly
only useful for things in PTK.
"""
return FormattedText(
[
("class:etc", self.prefix),
(
"class:hostname" if self.namestyle is None else self.namestyle,
f"{self.username}@{self.hostname}",
),
("class:etc", ":"),
("class:path", str(self.path)),
("class:etc", self.char),
]
)
