Python源码示例：tabulate.tabulate()
示例1
def do_agents(self,args):
""" list all agents in interacting """
list_agents = []
# get all session activated
if self.settings['agents'].keys() != {}:
for agent in self.settings['agents'].keys():
if self.settings['agents'][agent]['tunel'] != None:
if self.settings['agents'][agent]['tunel'].activated:
list_agents.append([agent,self.settings['agents'][agent]['creds']['Host'],
self.settings['agents'][agent]['creds']['Port'],
self.settings['agents'][agent]['tunel'].session.name,
self.settings['agents'][agent]['tunel'].session.pid])
if list_agents != []:
color.display_messages('Session Agents:', info=True, sublime=True)
print tabulate(list_agents,headers=C.headersAgents)
color.linefeed()
return color.display_messages('Online Agents: {}'.format(color.setcolor(str(len(list_agents)),
color='blue')), info=True)
color.display_messages('No agents in interacting', info=True)
示例2
def main():
args = parser.parse_args()
headers = ['filename', 'usWeightClass']
rows = []
for font in args.font:
ttfont = ttLib.TTFont(font)
rows.append([os.path.basename(font), ttfont['OS/2'].usWeightClass])
def as_csv(rows):
import csv
import sys
writer = csv.writer(sys.stdout)
writer.writerows([headers])
writer.writerows(rows)
sys.exit(0)
if args.csv:
as_csv(rows)
print(tabulate.tabulate(rows, headers, tablefmt="pipe"))
示例3
def printInfo(fonts, print_csv=False):
rows = []
headers = ['filename', 'fsSelection']
for font in fonts:
ttfont = ttLib.TTFont(font)
row = [os.path.basename(font)]
row.append(('{:#010b} '
'{:#010b}'
'').format(getByte2(ttfont),
getByte1(ttfont)).replace('0b', ''))
rows.append(row)
def as_csv(rows):
writer = csv.writer(sys.stdout)
writer.writerows([headers])
writer.writerows(rows)
sys.exit(0)
if print_csv:
as_csv(rows)
else:
print(tabulate.tabulate(rows, headers, tablefmt="pipe"))
示例4
def print_info(fonts, print_csv=False):
headers = ['filename', 'usWidthClass']
rows = []
warnings = []
for font in fonts:
ttfont = ttLib.TTFont(font)
usWidthClass = ttfont['OS/2'].usWidthClass
rows.append([os.path.basename(font), usWidthClass])
if usWidthClass != 5:
warning = "WARNING: {} is {}, expected 5"
warnings.append(warning.format(font, usWidthClass))
def as_csv(rows):
writer = csv.writer(sys.stdout)
writer.writerows([headers])
writer.writerows(rows)
sys.exit(0)
if print_csv:
as_csv(rows)
print(tabulate.tabulate(rows, headers, tablefmt="pipe"))
for warn in warnings:
print(warn, file=sys.stderr)
示例5
def format(self, findings):
table = []
for finding in findings:
url = str(finding.url) if finding.url else ''
severity = str(finding.severity.name) if finding.severity.name else ''
header = str(finding.header) if finding.header else ""
ftype = str(finding.ftype.name.lower()) if finding.ftype.name else ""
directive = str(finding.directive) if finding.directive else ""
value = str(finding.value) if finding.value else ""
description = str(finding.description) if finding.description else ""
f = finding
if self.hascolor:
color = self.getColor(finding.severity)
endColor = '\033[0m'
else:
color = ''
endColor = ''
table.append([url, color + severity + endColor +"", header, ftype, directive, value, description])
return str(tabulate(table, headers=["URL","Severity", "Header", "Finding Type", "Directive", "Value","Description"],tablefmt=self.tableformat))
示例6
def fix(fonts, value=None):
rows = []
headers = ['filename', 'usWidthClass was', 'usWidthClass now']
for font in fonts:
row = [font]
ttfont = ttLib.TTFont(font)
if not value:
usWidthClass = getFromFilename(font)
else:
usWidthClass = value
row.append(ttfont['OS/2'].usWidthClass)
ttfont['OS/2'].usWidthClass = usWidthClass
row.append(ttfont['OS/2'].usWidthClass)
ttfont.save(font + '.fix')
rows.append(row)
if rows:
print(tabulate.tabulate(rows, headers, tablefmt="pipe"))
示例7
def list_images(cli_ctx, short, installed):
'''List all configured images.'''
async def _impl():
async with config_ctx(cli_ctx) as config_server:
displayed_items = []
try:
items = await config_server.list_images()
for item in items:
if installed and not item['installed']:
continue
if short:
img = ImageRef(f"{item['name']}:{item['tag']}",
item['registry'])
displayed_items.append((img.canonical, item['digest']))
else:
pprint(item)
if short:
print(tabulate(displayed_items, tablefmt='plain'))
except Exception:
log.exception('An error occurred.')
with cli_ctx.logger:
asyncio.run(_impl())
示例8
def print_results_per_class(avg_cls_results, all_avg_results):
metrics = list(all_avg_results.keys())
# result printing
avg_results_print = copy.deepcopy(avg_cls_results)
avg_results_print['== Mean =='] = all_avg_results
tab_rows = []
for cls_, cls_metrics in avg_results_print.items():
tab_row = [cls_]
for metric in metrics:
val = cls_metrics[metric]
tab_row.append("%1.3f" % val)
tab_rows.append(tab_row)
headers = ['classes']
headers.extend(copy.deepcopy(metrics))
print(tabulate(tab_rows, headers=headers))
示例9
def _targets_heist(self, ctx):
"""Shows a list of targets"""
guild = ctx.guild
theme = await self.thief.get_guild_theme(guild)
targets = await self.thief.get_guild_targets(guild)
t_vault = theme["Vault"]
if len(targets.keys()) < 0:
msg = ("There aren't any targets! To create a target use {}heist "
"createtarget .".format(ctx.prefix))
else:
target_names = [x for x in targets]
crews = [int(subdict["Crew"]) for subdict in targets.values()]
success = [str(subdict["Success"]) + "%" for subdict in targets.values()]
vaults = [subdict["Vault"] for subdict in targets.values()]
data = list(zip(target_names, crews, vaults, success))
table_data = sorted(data, key=itemgetter(1), reverse=True)
table = tabulate(table_data, headers=["Target", "Max Crew", t_vault, "Success Rate"])
msg = "```C\n{}```".format(table)
await ctx.send(msg)
示例10
def validate_env(env, arch):
env_map = EnvClient().get_all()
envs = env_map.get(arch)
if envs:
if env not in envs:
envlist = tabulate([
[env_name]
for env_name in sorted(envs.keys())
])
floyd_logger.error("%s is not in the list of supported environments:\n%s", env, envlist)
return False
else:
floyd_logger.error("invalid instance type")
return False
return True
示例11
def info(job_name_or_id):
"""
View detailed information of a job.
"""
try:
experiment = ExperimentClient().get(normalize_job_name(job_name_or_id))
except FloydException:
experiment = ExperimentClient().get(job_name_or_id)
task_instance_id = get_module_task_instance_id(experiment.task_instances)
task_instance = TaskInstanceClient().get(task_instance_id) if task_instance_id else None
normalized_job_name = normalize_job_name(experiment.name)
table = [["Job name", normalized_job_name],
["Created", experiment.created_pretty],
["Status", experiment.state], ["Duration(s)", experiment.duration_rounded],
["Instance", experiment.instance_type_trimmed],
["Description", experiment.description],
["Metrics", format_metrics(experiment.latest_metrics)]]
if task_instance and task_instance.mode in ['jupyter', 'serving']:
table.append(["Mode", task_instance.mode])
table.append(["Url", experiment.service_url])
if experiment.tensorboard_url:
table.append(["TensorBoard", experiment.tensorboard_url])
floyd_logger.info(tabulate(table))
示例12
def test_numpy_2d():
"Input: a 2D NumPy array with headers."
try:
import numpy
na = (numpy.arange(1, 10, dtype=numpy.float32).reshape((3, 3)) ** 3) * 0.5
expected = "\n".join(
[
" a b c",
"----- ----- -----",
" 0.5 4 13.5",
" 32 62.5 108",
"171.5 256 364.5",
]
)
result = tabulate(na, ["a", "b", "c"])
assert_equal(expected, result)
except ImportError:
skip("test_numpy_2d is skipped")
示例13
def test_numpy_record_array():
"Input: a 2D NumPy record array without header."
try:
import numpy
na = numpy.asarray(
[("Alice", 23, 169.5), ("Bob", 27, 175.0)],
dtype={
"names": ["name", "age", "height"],
"formats": ["a32", "uint8", "float32"],
},
)
expected = "\n".join(
[
"----- -- -----",
"Alice 23 169.5",
"Bob 27 175",
"----- -- -----",
]
)
result = tabulate(na)
assert_equal(expected, result)
except ImportError:
skip("test_numpy_2d_keys is skipped")
示例14
def test_numpy_record_array_keys():
"Input: a 2D NumPy record array with column names as headers."
try:
import numpy
na = numpy.asarray(
[("Alice", 23, 169.5), ("Bob", 27, 175.0)],
dtype={
"names": ["name", "age", "height"],
"formats": ["a32", "uint8", "float32"],
},
)
expected = "\n".join(
[
"name age height",
"------ ----- --------",
"Alice 23 169.5",
"Bob 27 175",
]
)
result = tabulate(na, headers="keys")
assert_equal(expected, result)
except ImportError:
skip("test_numpy_2d_keys is skipped")
示例15
def test_numpy_record_array_headers():
"Input: a 2D NumPy record array with user-supplied headers."
try:
import numpy
na = numpy.asarray(
[("Alice", 23, 169.5), ("Bob", 27, 175.0)],
dtype={
"names": ["name", "age", "height"],
"formats": ["a32", "uint8", "float32"],
},
)
expected = "\n".join(
[
"person years cm",
"-------- ------- -----",
"Alice 23 169.5",
"Bob 27 175",
]
)
result = tabulate(na, headers=["person", "years", "cm"])
assert_equal(expected, result)
except ImportError:
skip("test_numpy_2d_keys is skipped")
示例16
def test_pandas():
"Input: a Pandas DataFrame."
try:
import pandas
df = pandas.DataFrame([["one", 1], ["two", None]], index=["a", "b"])
expected = "\n".join(
[
" string number",
"-- -------- --------",
"a one 1",
"b two nan",
]
)
result = tabulate(df, headers=["string", "number"])
assert_equal(expected, result)
except ImportError:
skip("test_pandas is skipped")
示例17
def test_sqlite3():
"Input: an sqlite3 cursor"
try:
import sqlite3
conn = sqlite3.connect(":memory:")
cursor = conn.cursor()
cursor.execute("CREATE TABLE people (name, age, height)")
for values in [("Alice", 23, 169.5), ("Bob", 27, 175.0)]:
cursor.execute("INSERT INTO people VALUES (?, ?, ?)", values)
cursor.execute("SELECT name, age, height FROM people ORDER BY name")
result = tabulate(cursor, headers=["whom", "how old", "how tall"])
expected = """\
whom how old how tall
------ --------- ----------
Alice 23 169.5
Bob 27 175"""
assert_equal(expected, result)
except ImportError:
skip("test_sqlite3 is skipped")
示例18
def test_sqlite3_keys():
"Input: an sqlite3 cursor with keys as headers"
try:
import sqlite3
conn = sqlite3.connect(":memory:")
cursor = conn.cursor()
cursor.execute("CREATE TABLE people (name, age, height)")
for values in [("Alice", 23, 169.5), ("Bob", 27, 175.0)]:
cursor.execute("INSERT INTO people VALUES (?, ?, ?)", values)
cursor.execute(
'SELECT name "whom", age "how old", height "how tall" FROM people ORDER BY name'
)
result = tabulate(cursor, headers="keys")
expected = """\
whom how old how tall
------ --------- ----------
Alice 23 169.5
Bob 27 175"""
assert_equal(expected, result)
except ImportError:
skip("test_sqlite3_keys is skipped")
示例19
def test_plain_multiline_with_empty_cells():
"Output: plain with multiline cells and empty cells with headers"
table = [
["hdr", "data", "fold"],
["1", "", ""],
["2", "very long data", "fold\nthis"],
]
expected = "\n".join(
[
" hdr data fold",
" 1",
" 2 very long data fold",
" this",
]
)
result = tabulate(table, headers="firstrow", tablefmt="plain")
assert_equal(expected, result)
示例20
def dump_tabular(self, print_func=None):
if len(self._curr_recorded) == 0:
return ''
### reset
self._curr_recorded = list()
self._num_dump_tabular_calls += 1
### make sure all same length
for k, v in self._tabular.items():
if len(v) == self._num_dump_tabular_calls:
pass
elif len(v) == self._num_dump_tabular_calls - 1:
self._tabular[k].append(np.nan)
else:
raise ValueError('key {0} should not have {1} items when {2} calls have been made'.format(
k, len(v), self._num_dump_tabular_calls))
### print
if print_func is not None:
log_str = tabulate(sorted([(k, v[-1]) for k, v in self._tabular.items()], key=lambda kv: kv[0]))
for line in log_str.split('\n'):
print_func(line)
### write to file
tabular_pandas = pandas.DataFrame({k: pandas.Series(v) for k, v in self._tabular.items()})
tabular_pandas.to_csv(self._csv_path)
示例21
def do_jobs(self,args):
""" list/kill jobs running on agents """
arg_parser = argparse.ArgumentParser(prog='jobs',description='list/kill jobs running on agents')
arg_parser.add_argument('-i', '--id', dest='id',type=int,metavar='<id>', help='kill agent by id')
arg_parser.add_argument('-k', '--kill',dest='kill', action='store_true', help='kill jobs by id/all')
arg_parser.add_argument('-l', '--list',dest='list', action='store_true', help='list all jobs')
try:
args=arg_parser.parse_args(shlex.split(args))
except: return
self.settings['all'] = {}
jobs = []
for agent in self.db.execute(C.selectAllBots):self.settings['all'][agent[0]] = agent
if self.settings['all'] == {}:
return color.display_messages('No Agents registered', info=True)
if args.list:
for agent in self.settings['agents'].keys():
if self.settings['agents'][int(agent)]['tunel'] != None:
if self.settings['agents'][int(agent)]['tunel'].jobs['Running']:
color.display_messages('Jobs:', info=True, sublime=True)
listjobs = self.settings['agents'][int(agent)]['tunel'].jobs['Packets']
listjobs.insert(0,int(agent))
jobs.append(listjobs)
if jobs != []:
print tabulate(jobs, headers=C.headersJobs)
return
color.display_messages('not command jobs activated', info=True)
elif args.id and args.kill:
if args.id in self.settings['agents'].keys():
if self.settings['agents'][args.id]['tunel'] != None:
return self.settings['agents'][args.id]['tunel'].job_stop()
color.display_messages('Job:: From Id {} not found'.format(args.id), info=True)
elif args.kill:
for agent in self.settings['agents'].keys():
if self.settings['agents'][int(agent)]['tunel'] != None:
self.settings['agents'][int(agent)]['tunel'].job_stop()
else:
arg_parser.print_help()
示例22
def do_check(self,args):
""" test all agents login ssh """
agentsCount = 0
self.settings['check'] = []
for agent in self.db.execute(C.selectAllBots):
agent = list(agent)
agent.insert(len(agent),self.sshConnect.ssh(agent[1],agent[2],agent[3],agent[4],checkconnect=True).status)
self.settings['check'].append(agent)
color.display_messages('Available Bots:', info=True, sublime=True)
print tabulate(self.settings['check'], headers=C.headersCheck)
for items in self.settings['check']:
if search('ON',items[6]):agentsCount +=1
color.linefeed()
color.display_messages('Online Agents: {}'.format(color.setcolor(str(agentsCount), color='blue')), info=True)
示例23
def generate_validation_history(step, tbl):
return tabulate(tbl, headers=['Step', 'LR', 'Loss'])
示例24
def print_dataframe(df):
print tabulate(df, headers='keys', tablefmt='psql', floatfmt=".0f")
示例25
def __str__(self):
rows = []
for key, value in self.__dict__.items():
if key == "snapshot_filename":
continue
rows.append([key, value])
return tabulate(rows, headers=["Hyperparameters", ""])
示例26
def __str__(self):
rows = []
for key, value in self.__dict__.items():
rows.append([key, value])
return tabulate(rows, headers=["Optimizer", ""])
示例27
def __str__(self):
rows = []
for key, value in self.__dict__.items():
if key == "snapshot_filename":
continue
rows.append([key, value])
return tabulate(rows, headers=["Pixel-Variance Scheduler", ""])
示例28
def to_table(rows=[]):
"""
Transform rows in a table
"""
# Retrieve id and name
all_secrets = [[secret.id, get_category_name(secret.category_id), secret.name,
secret.url, secret.login] for secret in rows]
if len(all_secrets) > 0:
return tabulate(all_secrets, headers=['Item', 'Category', 'Name', 'URL', 'Login'])
else:
return 'Empty!'
示例29
def to_table(rows=[]):
"""
Transform rows in a table
"""
# Retrieve id and name
cats = [[cat.id, cat.name] for cat in rows]
if len(cats) > 0:
return tabulate(cats, headers=['Item', 'Category name'])
else:
return 'Empty!'
示例30
def to_table(rows=[]):
"""
Transform rows in a table
"""
if len(rows) > 0:
return tabulate(rows, headers=['Name', 'URL', 'Login', 'Category'])
else:
return 'Empty!'
