def show(self, id, sort, current):
deferred = Tasks.client.get_tasks(id)
result = sync_wait(deferred)
if not id:
values = []
if current:
result = [
t for t in result if TaskStatus(t['status']).is_active()
]
for task in result:
values.append([
task['id'],
Tasks.__format_seconds(task['time_remaining']),
str(task['subtasks_count']), task['status'],
Tasks.__progress_str(task['progress'])
])
return CommandResult.to_tabular(Tasks.task_table_headers,
values,
sort=sort)
if isinstance(result, dict):
result['time_remaining'] = \
Tasks.__format_seconds(result['time_remaining'])
result['progress'] = Tasks.__progress_str(result['progress'])
return result
def payments(sort):
deferred = payments.client.get_payments_list()
result = sync_wait(deferred) or []
values = []
for payment in result:
payment_value = float(payment["value"])
payment_fee = payment["fee"] or u""
if payment_fee:
payment_fee = u"{:.1f}%".format(float(payment_fee) * 100 /
payment_value)
entry = [
payment["subtask"],
payment["payee"].encode('hex'),
__status(payment),
__value(payment_value),
payment_fee
]
values.append(entry)
return CommandResult.to_tabular(payments_table_headers, values, sort=sort)
def payments(sort, status):
deferred = payments.client.get_payments_list()
result = sync_wait(deferred) or []
values = []
if status is not None:
result = filter_by_status(result, status)
for payment in result:
payment_value = float(payment["value"])
payment_fee = payment["fee"] or ""
if payment_fee:
payment_fee = __value(payment_fee, "ETH")
entry = [
to_unicode(payment["subtask"]),
to_unicode(payment["payee"]),
to_unicode(payment["status"]),
__value(payment_value, "GNT"),
to_unicode(payment_fee)
]
values.append(entry)
return CommandResult.to_tabular(payments_table_headers, values, sort=sort)
def test_command_formatter(self):
formatter = CommandFormatter()
for prettify in [True, False]:
formatter.prettify = prettify
self.assertIsNone(formatter.format(None))
self.assertIsNone(formatter.format(''))
self.assertEqual(formatter.format('Some text'), 'Some text')
if not prettify:
self.assertEqual(formatter.format(formatter),
DictSerializer.dump(formatter, typed=False))
table_headers = ['First', 'Second', 'Third']
table_values = [
['value 1', 'value 2', 'value 3'],
['value 1', 'value 2', 'value 3'],
['value 1', 'value 2', 'value 3'],
]
tabular_result = CommandResult.to_tabular(table_headers, table_values)
tabular_repr = formatter.format(tabular_result)
tabular_data_repr = formatter.format(tabular_result.from_tabular())
self.assertIsNotNone(tabular_repr)
self.assertIsNotNone(tabular_data_repr)
self.assertNotEqual(tabular_data_repr, tabular_repr)
def test_tabular(self):
headers = ['1', '2', '3']
values = [
['d', 'b', 'f'],
['a', 'e', 'c'],
]
tabular = CommandResult.to_tabular(headers, values)
self.assertEqual(tabular.data, (headers, values))
self.assertEqual(tabular.type, CommandResult.TABULAR)
self.assertEqual(tabular.from_tabular(), (headers, values))
tabular = CommandResult.to_tabular(headers, values, sort='4')
self.assertEqual(tabular.from_tabular()[1], values)
tabular = CommandResult.to_tabular(headers, values, sort='1')
self.assertNotEqual(tabular.from_tabular()[1], values)
self.assertEqual(tabular.from_tabular()[1], [
['a', 'e', 'c'],
['d', 'b', 'f'],
])
tabular = CommandResult.to_tabular(headers, values, sort='2')
self.assertEqual(tabular.from_tabular()[1], values)
tabular = CommandResult.to_tabular(headers, values, sort='3')
self.assertNotEqual(tabular.from_tabular()[1], values)
self.assertEqual(tabular.from_tabular()[1], [
['a', 'e', 'c'],
['d', 'b', 'f'],
])
CommandResult.type = CommandResult.NONE
with self.assertRaises(TypeError):
CommandResult.from_tabular()
CommandResult.type = CommandResult.TABULAR
def __peers(peers, sort, full):
values = []
for peer in peers:
values.append([
str(peer['address']),
str(peer['port']),
Network.__key_id(peer['key_id'], full),
unicode(peer['node_name'])
])
return CommandResult.to_tabular(Network.node_table_headers,
values,
sort=sort)
def incomes(sort):
deferred = incomes.client.get_incomes_list()
result = sync_wait(deferred) or []
values = []
for income in result:
entry = [
income["payer"].encode('hex'),
__status(income),
__value(float(income["value"])),
str(income["block_number"])
]
values.append(entry)
return CommandResult.to_tabular(payments_table_headers, values, sort=sort)
def subtasks(self, id, sort):
values = []
deferred = Tasks.client.get_subtasks(id)
result = sync_wait(deferred)
if isinstance(result, list):
for subtask in result:
values.append([
subtask['node_name'], subtask['subtask_id'],
str(subtask['time_remaining']), subtask['status'],
Tasks.__progress_str(subtask['progress'])
])
return CommandResult.to_tabular(Tasks.subtask_table_headers,
values,
sort=sort)
def incomes(sort, status):
deferred = incomes.client.get_incomes_list()
result = sync_wait(deferred) or []
values = []
if status is not None:
result = filter_by_status(result, status)
for income in result:
entry = [
to_unicode(income["payer"]),
to_unicode(income["status"]),
__value(float(income["value"]), "GNT"),
]
values.append(entry)
return CommandResult.to_tabular(incomes_table_headers, values, sort=sort)
def test_command_formatter_table_format(self):
formatter = CommandFormatter()
table_headers = ['First', 'Second', 'Third']
table_values = [
['value 1', 'value 2', 'value 3'],
['value 1', 'value 2', 'value 3'],
['value 1', 'value 2', 'value 3'],
]
tabular_result = CommandResult.to_tabular(table_headers, table_values)
tabular_repr = formatter.format(tabular_result)
tabular_data_repr = formatter.format(tabular_result.from_tabular())
self.assertIsNotNone(tabular_repr)
self.assertIsNotNone(tabular_data_repr)
self.assertNotEqual(tabular_data_repr, tabular_repr)
def __peers(peers, sort, full):
values = []
for p in peers:
addr = Network.__one_of(p, 'address', 'pub_addr')
port = Network.__one_of(p, 'port', 'p2p_pub_port', 'p2p_prv_port')
key = Network.__one_of(p, 'key_id', 'key')
values.append([
str(addr),
str(port),
Network.__key_id(key, full),
str(p['node_name']),
])
return CommandResult.to_tabular(Network.node_table_headers,
values,
sort=sort)
def show(self, sort):
deferred = Environments.client.get_environments()
result = sync_wait(deferred) or []
values = []
for env in result:
values.append([
env['id'],
str(env['supported']),
str(env['accepted']),
str(env['performance']),
env['description']
])
return CommandResult.to_tabular(Environments.table_headers, values,
sort=sort)
def show(self, id, sort):
deferred = Tasks.client.get_tasks(id)
result = sync_wait(deferred)
if not id:
values = []
for task in result or []:
values.append([
task['id'],
str(task['time_remaining']),
str(task['subtasks']), task['status'],
Tasks.__progress_str(task['progress'])
])
return CommandResult.to_tabular(Tasks.task_table_headers,
values,
sort=sort)
if isinstance(result, dict):
result['progress'] = Tasks.__progress_str(result['progress'])
return result
def unsupport(self, last_days):
deferred = Tasks.client.get_unsupport_reasons(int(last_days))
result = sync_wait(deferred)
values = [[r['reason'], r['ntasks'], r['avg']] for r in result]
return CommandResult.to_tabular(Tasks.unsupport_reasons_table_headers,
values)
def show(self):
res = sync_wait(Resources.client.get_res_dirs_sizes(), timeout=None)
return CommandResult.to_tabular(list(res.keys()), [list(res.values())])