def option(self):
"""
Print the options required by the module
Usage: options [-h]
Options:
-h, --help print this help menu
"""
table_data = [
["Name", "Current Settings", "Required", "Description"]
]
for name, options in self.options.items():
table_data.append([name, options["Current Settings"], options["Require"], options["Description"]])
table = AsciiTable(table_data)
table.inner_column_border = False
table.inner_footing_row_border = False
table.inner_heading_row_border = True
table.inner_row_border = False
table.outer_border = False
print (f'\nModule Options ({self.name}):\n\n{table.table}\n')
def main() :
# Parameters
time_start = datetime.datetime.now()
file_config = os.path.join(os.path.dirname(__file__), 'conf/config.ini')
Config = ConfigParser.ConfigParser()
Config.read(file_config)
# Logging setup
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(Config.get('GLOBAL','application'))
handler = logging.FileHandler(os.path.join(os.path.dirname(__file__), 'log/'+Config.get('GLOBAL','application')+'.log'))
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
# Options
parser = argparse.ArgumentParser(description='Simple tool to add client into Nagios config files')
parser.add_argument('--address', action='store', dest='address', help='FQDN of the asset', required=True)
parser.add_argument('--hosttype', action='store', dest='hosttype', choices=['linux-server','generic-switch'], required=True)
parser.add_argument('--hostgroups', action='store', dest='hostgroups', help='List of hostgroup(s) comma separated', required=True)
args = parser.parse_args()
try :
# MNCM objects instance
inst_mncm = MncmMotor(Config.get('GLOBAL','application'), Config.get('NAGIOS','myhostgroups'), Config.get('NAGIOS','myassetsdir'))
# Check if the client doesn't exist already
logger.info('Check if client "' + str(args.address) + '" is not already part of this configuration')
if inst_mncm.host_exist(str(args.address)) :
raise RuntimeError('The client "' + str(args.address) + '" is already part of this configuration')
# Check if the hostgroups exist
logger.info('Check if hostgroup(s) "' + str(args.hostgroups.split(',')) + '" is part of this configuration')
inst_mncm.hostgroups_exist(str(args.hostgroups).split(','))
# We can add the client :)
logger.info('Adding client "' + str(args.address) + '" in the Nagios configuration with hostgroup(s) "' + str(args.hostgroups.split(',')) + '"')
inst_mncm.add_host(str(args.address),str(args.hostgroups).split(','),str(args.hosttype))
# Ascii table
myAsciiTable = [['Client address','Type','Hostgroup(s)','Action']]
tmpdata = list()
tmpdata.append(str(args.address)) # Address
tmpdata.append(str(args.hosttype)) # Hosttype
tmpdata.append(str(args.hostgroups)) # Hostgroup(s)
tmpdata.append('Added') # Action
# Add tmpdata list to myAsciiTable
myAsciiTable.append(tmpdata)
myTable = AsciiTable(myAsciiTable)
myTable.inner_footing_row_border = True
# End script
time_stop = datetime.datetime.now()
time_delta = time_stop - time_start
# Output data
print "######### DATE : %s - APP : %s #########" % (time_start.strftime("%Y-%m-%d"),Config.get('GLOBAL','application'))
print "- Start time : %s" % (time_start.strftime("%Y-%m-%d %H:%M:%S"))
print "- Finish time : %s" % (time_stop.strftime("%Y-%m-%d %H:%M:%S"))
print "- Delta time : %d second(s)" % (time_delta.total_seconds())
print myTable.table
except Exception as e :
logger.error('RunTimeError during instance creation : %s', str(e))
def paths(ctx):
repos = ctx.obj.get("repos")
output_format = ctx.obj.get("output_format")
order = ctx.obj.get("order")
parallel_workers = ctx.obj.get("parallel_workers")
prog = progressbar(length=len(repos),
show_eta=False,
label="Fetching paths stats",
item_show_func=lambda r: r and r.name)
with prog, ThreadPoolExecutor(max_workers=parallel_workers) as executor:
def get(repo):
try:
resp = repo.get_top_paths()
except github.RateLimitExceededException as e:
retry_after = int(e.headers.get("retry-after", 0))
if retry_after:
time.sleep(retry_after)
resp = repo.get_top_paths()
else:
raise e
return resp, repo
futures = (executor.submit(get, repo) for repo in repos)
paths = []
for f in concurrent.futures.as_completed(futures):
top_paths, repo = f.result()
prog.update(1, repo)
for p in top_paths:
paths.append({
"repo": repo.name,
"path": p.path,
"title": p.title,
"count": p.count,
"uniques": p.uniques
})
paths = sorted(paths,
key=lambda x: (x["uniques"], x["count"], x["repo"]),
reverse=True if order == "desc" else False)
if output_format == "json":
click.echo(json.dumps(paths, indent=4, sort_keys=True))
elif output_format == "table":
labels = [["Repo", "Path", "Uniques", "Count"]]
rows = []
for path in paths:
rows.append(
[path["repo"], path["path"], path["uniques"], path["count"]])
table_rows = labels + rows + labels
table = AsciiTable(table_rows, "Paths")
table.inner_footing_row_border = True
click.secho(table.table)
def test_single_line():
"""Test single-lined cells."""
table_data = [
['Name', 'Color', 'Type'],
['Avocado', 'green', 'nut'],
['Tomato', 'red', 'fruit'],
['Lettuce', 'green', 'vegetable'],
['Watermelon', 'green'],
[],
]
table = AsciiTable(table_data, 'Example')
table.inner_footing_row_border = True
table.justify_columns[0] = 'left'
table.justify_columns[1] = 'center'
table.justify_columns[2] = 'right'
actual = table.table
expected = (
'+Example-----+-------+-----------+\n'
'| Name | Color | Type |\n'
'+------------+-------+-----------+\n'
'| Avocado | green | nut |\n'
'| Tomato | red | fruit |\n'
'| Lettuce | green | vegetable |\n'
'| Watermelon | green | |\n'
'+------------+-------+-----------+\n'
'| | | |\n'
'+------------+-------+-----------+'
)
assert actual == expected
def render_matched_rules_as_table(state, rules):
"""
Renders the provided, flattened backup rules (matched) as a table.
:param state: rules state (included or excluded)
:param rules: rules to render
:return: rendered table string
"""
if rules:
header = [[
'State',
'Entity',
'Explanation',
]]
footer = [[state, 'Total: {}'.format(len(rules)), '-']]
table = AsciiTable(header + list(
map(
lambda rule: [
rule['state'],
rule['entity'],
rule['explanation'],
], rules)) + footer)
table.inner_footing_row_border = True
return table.table
else:
return 'No data'
def print(self):
""" Print cart contents """
table_data = []
tables_headers = ['Item', ' ', 'Price']
border_row = ["----", "", "-----"]
table_data.append(tables_headers)
table_data.append(border_row)
msg = ""
for item in self.contents():
row = [item.product_code, "", "{0:.2f}".format(item.price)]
table_data.append(row)
if item.discount:
discount_row = ["", item.coupon, f"-{item.discount}"]
table_data.append(discount_row)
total_row = ["", "", "{0:.2f}".format(self.total())]
table_data.append(total_row)
table = AsciiTable(table_data=table_data)
table.inner_column_border = False
table.outer_border = False
table.inner_heading_row_border = False
table.inner_footing_row_border = True
table.justify_columns[1] = 'center' # Justify coupons center
table.justify_columns[2] = 'right' # Justify prices right
msg += table.table
return msg
def main_help():
commands = ['database', 'sniffing', 'exploit', 'modelling', 'exit']
description = [
'Use database mode.', 'Use sniffing mode.', 'Use exploit mode.',
'Use modelling mode.', 'Quit this program'
]
table_data = [['Commands', 'Description']]
for i in range(len(commands) - 1):
table_data.append([commands[i], description[i]])
table = AsciiTable(table_data)
table.inner_column_border = False
table.inner_footing_row_border = False
table.inner_heading_row_border = True
table.inner_row_border = False
table.outer_border = False
msg = f"""
Core commands
=============
{table.table}\n\n"""
return msg
def print_map_summary(mAP, APs, dataset=None):
"""Print mAP and results of each class.
Args:
mAP(float): calculated from `eval_map`
APs(ndarray): calculated from `eval_map`
dataset(None or str or list): dataset name or dataset classes.
"""
num_classes = APs.shape[0]
if dataset is None:
label_names = [str(i) for i in range(1, num_classes + 1)]
elif mmcv.is_str(dataset):
label_names = get_classes(dataset)
else:
label_names = list(dataset)
header = ['class', 'ap']
table_data = [header]
for j in range(num_classes):
row_data = [
label_names[j], '{:.4f}'.format(APs[j])
]
table_data.append(row_data)
table_data.append(['mAP', '{:.4f}'.format(mAP)])
table = AsciiTable(table_data)
table.inner_footing_row_border = True
print(table.table)
def print_map_summary(mean_ap,
results,
dataset=None,
ranges=None,
work_dir=None):
"""Print mAP and results of each class.
Args:
mean_ap(float): calculated from `eval_map`
results(list): calculated from `eval_map`
dataset(None or str or list): dataset name or dataset classes.
ranges(list or Tuple): ranges of areas
"""
num_scales = len(results[0]['ap']) if isinstance(results[0]['ap'],
np.ndarray) else 1
if ranges is not None:
assert len(ranges) == num_scales
num_classes = len(results)
recalls = np.zeros((num_scales, num_classes), dtype=np.float32)
precisions = np.zeros((num_scales, num_classes), dtype=np.float32)
aps = np.zeros((num_scales, num_classes), dtype=np.float32)
num_gts = np.zeros((num_scales, num_classes), dtype=int)
for i, cls_result in enumerate(results):
if cls_result['recall'].size > 0:
recalls[:, i] = np.array(cls_result['recall'], ndmin=2)[:, -1]
precisions[:, i] = np.array(cls_result['precision'], ndmin=2)[:,
-1]
aps[:, i] = cls_result['ap']
num_gts[:, i] = cls_result['num_gts']
if dataset is None:
label_names = [str(i) for i in range(1, num_classes + 1)]
elif mmcv.is_str(dataset):
label_names = get_classes(dataset)
else:
label_names = dataset
if not isinstance(mean_ap, list):
mean_ap = [mean_ap]
header = ['class', 'gts', 'dets', 'recall', 'precision', 'ap']
for i in range(num_scales):
if ranges is not None:
print("Area range ", ranges[i])
table_data = [header]
for j in range(num_classes):
row_data = [
label_names[j], num_gts[i, j], results[j]['num_dets'],
'{:.3f}'.format(recalls[i, j]),
'{:.3f}'.format(precisions[i, j]), '{:.3f}'.format(aps[i, j])
]
table_data.append(row_data)
table_data.append(['mAP', '', '', '', '', '{:.3f}'.format(mean_ap[i])])
table = AsciiTable(table_data)
table.inner_footing_row_border = True
print(table.table)
if work_dir is not None and mmcv.is_str(work_dir):
with open(work_dir, 'a+') as f:
print(table.table, file=f)
def render_basic(data, title=None):
table = AsciiTable(data, title=title)
table.inner_row_border = True
table.inner_footing_row_border = True
table.padding_left = 5
table.padding_right = 5
print(table.table)
print("\n")
def print_map_summary(mean_ap,
results,
dataset=None,
scale_ranges=None):
"""Print mAP and results of each class.
A table will be printed to show the gts/dets/recall/AP of each class and
the mAP.
Args:
mean_ap (float): Calculated from `eval_map()`.
results (list[dict]): Calculated from `eval_map()`.
dataset (list[str] | str | None): Dataset name or dataset classes.
scale_ranges (list[tuple] | None): Range of scales to be evaluated.
"""
if isinstance(results[0]['ap'], np.ndarray):
num_scales = len(results[0]['ap'])
else:
num_scales = 1
if scale_ranges is not None:
assert len(scale_ranges) == num_scales
num_classes = len(results)
recalls = np.zeros((num_scales, num_classes), dtype=np.float32)
aps = np.zeros((num_scales, num_classes), dtype=np.float32)
num_gts = np.zeros((num_scales, num_classes), dtype=int)
for i, cls_result in enumerate(results):
if cls_result['recall'].size > 0:
recalls[:, i] = np.array(cls_result['recall'], ndmin=2)[:, -1]
aps[:, i] = cls_result['ap']
num_gts[:, i] = cls_result['num_gts']
if dataset is None:
label_names = [str(i) for i in range(num_classes)]
else:
label_names = get_classes(dataset)
if not isinstance(mean_ap, list):
mean_ap = [mean_ap]
header = ['class', 'gts', 'dets', 'recall', 'ap']
for i in range(num_scales):
if scale_ranges is not None:
print(f'Scale range {scale_ranges[i]}')
table_data = [header]
for j in range(num_classes):
row_data = [
label_names[j], num_gts[i, j], results[j]['num_dets'],
f'{recalls[i, j]:.3f}', f'{aps[i, j]:.3f}'
]
table_data.append(row_data)
table_data.append(['mAP', '', '', '', f'{mean_ap[i]:.3f}'])
table = AsciiTable(table_data)
table.inner_footing_row_border = True
print('\n' + table.table)
def print_summary_table(out_prefix,
project,
toolchain,
board,
build_type,
build_nr=None):
"""Prints a summary table of the outcome of each test."""
builds = get_builds(out_prefix)
table_data = [[
'Project', 'Toolchain', 'Family', 'Part', 'Board', 'Build Type',
'Build N.', 'Options'
]]
passed = failed = 0
build_count = 0
for build in sorted(builds):
# Split directory name into columns
# Example: oneblink_vpr_xc7_a35tcsg326-1_arty_generic-build_0_options
pattern = ''
for i in range(0, len(table_data[0]) - 1):
pattern += '([^_]*)_'
pattern += '(.*)'
row = list(re.match(pattern, build).groups())
if build_type != row[5] or (build_nr and int(build_nr) != int(row[6])):
continue
if project and row[0] not in project:
continue
if toolchain and row[1] not in toolchain:
continue
if board and row[4] not in board:
continue
# Check if metadata was generated
# It is created for successful builds only
if os.path.exists(
os.path.join(root_dir, out_prefix, build, 'meta.json')):
row.append(Color('{autogreen}passed{/autogreen}'))
passed += 1
else:
row.append(Color('{autored}failed{/autored}'))
failed += 1
table_data.append(row)
build_count += 1
table_data.append([
Color('{autogreen}Passed:{/autogreen}'), passed,
Color('{autored}Failed:{/autored}'), failed, '', '', '', '',
'{}%'.format(int(passed / build_count * 100))
])
table = AsciiTable(table_data)
table.inner_footing_row_border = True
print(table.table)
return failed == 0
def tables(matriz, ult_borda=False, title="", separar_linhas=False):
""" Recebe a tabela em formatos Matriz e a imprime no terminal."""
tables_terminal = AsciiTable(matriz)
tables_terminal.inner_footing_row_border = ult_borda
tables_terminal.inner_row_border = separar_linhas
tables_terminal.title = title
if tables_terminal.ok:
print(tables_terminal.table)
else:
print(
"Tabela Muito grande, Recue o zoom\nou aumente a janela do terminal!"
)
def get_snapshots(args):
try:
from terminaltables import AsciiTable
except ImportError:
AsciiTable = False
pass
response = requests.get(args.host + "/api/public/v1.0/groups/" +
args.group + "/clusters/" + args.clusterId +
"/snapshots",
auth=HTTPDigestAuth(args.username, args.apikey))
response.raise_for_status()
vprint("============= response ==============", args)
vprint(vars(response), args)
vprint("============= end response ==============", args)
hosts_json = response.json()
vprint(hosts_json, args)
table_data = [[
'created', 'expires', 'complete', 'replicaSetName', 'id', 'parts'
]]
for host in hosts_json['results']:
row = []
part_data = [[
'replicaSetName', 'storageSizeBytes', 'mongodbVersion', 'typeName',
'fileSizeBytes', 'dataSizeBytes'
]]
for column in table_data[0]:
if column == 'parts':
parts = []
for part in host['parts']:
for pcol in part_data[0]:
parts.append(pcol + ":" + str(part.get(pcol)))
parts.append("++++++++++++++")
row.append(str.join("\n", parts))
elif column == 'created':
row.append(str(host.get('created').get('date')))
else:
row.append(str(host.get(column)))
table_data.append(row)
table_data.append(
['', '', 'Number of snapshots',
str(hosts_json['totalCount'])])
host_info = 'Snapshots from ' + args.host + " for clusterId=" + args.clusterId
if AsciiTable:
table = AsciiTable(table_data, host_info)
table.inner_footing_row_border = True
print table.table
else:
import pprint
pprint.pprint(table_data)
def ps(gravitee_api, deploy_state):
"""APIs list"""
resp = gravitee_api.get_apis()
if not resp:
click.echo("No Api(s) found ")
else:
data = []
if deploy_state:
data.append(['id', 'Name', 'Synchronized', 'Status'])
else:
data.append(['id', 'Name', 'Status'])
for api_item in resp.json():
if api_item['state'] == 'started':
state_color = 'green'
else:
state_color = 'red'
if 'workflow_state' in api_item:
state = click.style(api_item['workflow_state'].upper(),
fg='blue') + "-" + click.style(
api_item['state'].upper(),
fg=state_color)
else:
state = click.style(api_item['state'].upper(), fg=state_color)
if deploy_state:
response_state = gravitee_api.state_api(api_item['id'])
synchronized = click.style("X", fg='yellow')
if response_state.json()["is_synchronized"]:
synchronized = click.style("V", fg='green')
data.append(
[api_item['id'], api_item['name'], synchronized, state])
else:
if api_item['state'] == 'started':
color = 'green'
else:
color = 'red'
data.append([api_item['id'], api_item['name'], state])
table = AsciiTable(data)
table.inner_footing_row_border = False
table.inner_row_border = False
table.inner_column_border = False
table.outer_border = False
if deploy_state:
table.justify_columns[2] = 'center'
click.echo(table.table)
def echo(self, data):
table = AsciiTable(data)
table.inner_footing_row_border = False
table.inner_row_border = False
table.inner_column_border = False
table.outer_border = False
# print("{}".format(justify_columns))
if not self.style is None:
table.justify_columns = self.style
click.echo(table.table)
def seg_eval(gt_labels, seg_preds, label2cat, logger=None):
"""Semantic Segmentation Evaluation.
Evaluate the result of the Semantic Segmentation.
Args:
gt_labels (list[torch.Tensor]): Ground truth labels.
seg_preds (list[torch.Tensor]): Predtictions
label2cat (dict): Map from label to category.
logger (logging.Logger | str | None): The way to print the mAP
summary. See `mmdet.utils.print_log()` for details. Default: None.
Return:
dict[str, float]: Dict of results.
"""
assert len(seg_preds) == len(gt_labels)
hist_list = []
for i in range(len(seg_preds)):
hist_list.append(
fast_hist(seg_preds[i].numpy().astype(int),
gt_labels[i].numpy().astype(int), len(label2cat)))
iou = per_class_iou(sum(hist_list))
miou = np.nanmean(iou)
acc = get_acc(sum(hist_list))
acc_cls = get_acc_cls(sum(hist_list))
header = ['classes']
for i in range(len(label2cat)):
header.append(label2cat[i])
header.extend(['miou', 'acc', 'acc_cls'])
ret_dict = dict()
table_columns = [['results']]
for i in range(len(label2cat)):
ret_dict[label2cat[i]] = float(iou[i])
table_columns.append([f'{iou[i]:.4f}'])
ret_dict['miou'] = float(miou)
ret_dict['acc'] = float(acc)
ret_dict['acc_cls'] = float(acc_cls)
table_columns.append([f'{miou:.4f}'])
table_columns.append([f'{acc:.4f}'])
table_columns.append([f'{acc_cls:.4f}'])
table_data = [header]
table_rows = list(zip(*table_columns))
table_data += table_rows
table = AsciiTable(table_data)
table.inner_footing_row_border = True
print_log('\n' + table.table, logger=logger)
return ret_dict
def print(self, data, **kwargs):
table = AsciiTable(data)
table.inner_footing_row_border = False
table.inner_row_border = False
table.inner_column_border = False
table.outer_border = False
if "inner_heading_row_border" in kwargs:
table.inner_heading_row_border = kwargs["inner_heading_row_border"]
if "style" in kwargs:
table.justify_columns = kwargs["style"]
click.echo(table.table)
def print_map_summary(mean_ap, results, dataset=None):
"""Print mAP and results of each class.
Args:
mean_ap(float): calculated from `eval_map`
results(list): calculated from `eval_map`
dataset(None or str or list): dataset name or dataset classes.
"""
num_scales = (len(results[0]["ap"])
if isinstance(results[0]["ap"], np.ndarray) else 1)
num_classes = len(results)
recalls = np.zeros((num_scales, num_classes), dtype=np.float32)
precisions = np.zeros((num_scales, num_classes), dtype=np.float32)
aps = np.zeros((num_scales, num_classes), dtype=np.float32)
num_gts = np.zeros((num_scales, num_classes), dtype=int)
for i, cls_result in enumerate(results):
if cls_result["recall"].size > 0:
recalls[:, i] = np.array(cls_result["recall"], ndmin=2)[:, -1]
precisions[:, i] = np.array(cls_result["precision"], ndmin=2)[:,
-1]
aps[:, i] = cls_result["ap"]
num_gts[:, i] = cls_result["num_gts"]
if dataset is None:
label_names = [str(i) for i in range(1, num_classes + 1)]
elif mmcv.is_str(dataset):
label_names = get_classes(dataset)
else:
label_names = dataset
if not isinstance(mean_ap, list):
mean_ap = [mean_ap]
header = ["class", "gts", "dets", "recall", "precision", "ap"]
for i in range(num_scales):
table_data = [header]
for j in range(num_classes):
row_data = [
label_names[j],
num_gts[i, j],
results[j]["num_dets"],
"{:.3f}".format(recalls[i, j]),
"{:.3f}".format(precisions[i, j]),
"{:.3f}".format(aps[i, j]),
]
table_data.append(row_data)
table_data.append(["mAP", "", "", "", "", "{:.3f}".format(mean_ap[i])])
table = AsciiTable(table_data)
table.inner_footing_row_border = True
print(table.table)
def lyft_eval(lyft, data_root, res_path, eval_set, output_dir, logger=None):
"""Evaluation API for Lyft dataset.
Args:
lyft (:obj:`LyftDataset`): Lyft class in the sdk.
data_root (str): Root of data for reading splits.
res_path (str): Path of result json file recording detections.
eval_set (str): Name of the split for evaluation.
output_dir (str): Output directory for output json files.
logger (logging.Logger | str | None): Logger used for printing
related information during evaluation. Default: None.
Returns:
dict[str, float]: The evaluation results.
"""
# evaluate by lyft metrics
gts = load_lyft_gts(lyft, data_root, eval_set, logger)
predictions = load_lyft_predictions(res_path)
class_names = get_class_names(gts)
print('Calculating [email protected]:0.95...')
iou_thresholds = [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]
metrics = {}
average_precisions = \
get_classwise_aps(gts, predictions, class_names, iou_thresholds)
APs_data = [['IOU', 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]]
mAPs = np.mean(average_precisions, axis=0)
mAPs_cate = np.mean(average_precisions, axis=1)
final_mAP = np.mean(mAPs)
metrics['average_precisions'] = average_precisions.tolist()
metrics['mAPs'] = mAPs.tolist()
metrics['Final mAP'] = float(final_mAP)
metrics['class_names'] = class_names
metrics['mAPs_cate'] = mAPs_cate.tolist()
APs_data = [['class', '[email protected]:0.95']]
for i in range(len(class_names)):
row = [class_names[i], round(mAPs_cate[i], 3)]
APs_data.append(row)
APs_data.append(['Overall', round(final_mAP, 3)])
APs_table = AsciiTable(APs_data, title='[email protected]:0.95')
APs_table.inner_footing_row_border = True
print_log(APs_table.table, logger=logger)
res_path = osp.join(output_dir, 'lyft_metrics.json')
mmcv.dump(metrics, res_path)
return metrics
def get_alerts(args):
try:
from terminaltables import AsciiTable
except ImportError:
AsciiTable = False
pass
if args.format == 'json':
AsciiTable = False
host = args.host
group_id = args.group
user_name = args.username
api_key = args.apikey
response = requests.get(host + "/api/public/v1.0/groups/" + group_id +
"/alerts/",
auth=HTTPDigestAuth(user_name, api_key))
response.raise_for_status()
vprint("============= response ==============", args)
vprint(vars(response), args)
vprint("============= end response ==============", args)
alerts_json = response.json()
table_data = [['eventTypeName', 'status', 'created', 'replicaSetName']]
for alert in alerts_json['results']:
row = [
str(alert.get('eventTypeName')),
str(alert.get('status')),
str(alert.get('created')),
str(alert.get('replicaSetName', ''))
]
table_data.append(row)
table_data.append(
['', '', 'Number alerts',
str(alerts_json['totalCount'])])
host_info = 'Alerts from ' + host
if AsciiTable:
table = AsciiTable(table_data, host_info)
table.inner_footing_row_border = True
print table.table
else:
if args.format == 'json':
print(json.dumps(alerts_json))
else:
import pprint
pprint.pprint(table_data)
return alerts_json
def print_map_summary(mean_ap, results, dataset=None):
"""Print mAP and results of each class.
Args:
mean_ap(float): calculated from `eval_map`
results(list): calculated from `eval_map`
dataset(None or str or list): dataset name or dataset classes.
"""
num_scales = len(results[0]['ap']) if isinstance(results[0]['ap'],
np.ndarray) else 1
num_classes = len(results)
recalls = np.zeros((num_scales, num_classes), dtype=np.float32)
precisions = np.zeros((num_scales, num_classes), dtype=np.float32)
aps = np.zeros((num_scales, num_classes), dtype=np.float32)
num_gts = np.zeros((num_scales, num_classes), dtype=int)
for i, cls_result in enumerate(results):
if cls_result['recall'].size > 0:
recalls[:, i] = np.array(cls_result['recall'], ndmin=2)[:, -1]
precisions[:, i] = np.array(
cls_result['precision'], ndmin=2)[:, -1]
aps[:, i] = cls_result['ap']
num_gts[:, i] = cls_result['num_gts']
if dataset is None:
label_names = [str(i) for i in range(1, num_classes + 1)]
elif mmcv.is_str(dataset):
label_names = get_classes(dataset)
else:
label_names = dataset
if not isinstance(mean_ap, list):
mean_ap = [mean_ap]
header = ['class', 'gts', 'dets', 'recall', 'precision', 'ap']
for i in range(num_scales):
table_data = [header]
for j in range(num_classes): # when eval voc dataset, the num_classes are default to 80, while voc have only 20 classes in list of label_nmae it may cause list index out of range
if dataset == 'voc07' and j == 1:
break
row_data = [
label_names[j], num_gts[i, j], results[j]['num_dets'],
'{:.3f}'.format(recalls[i, j]), '{:.3f}'.format(
precisions[i, j]), '{:.3f}'.format(aps[i, j])
]
table_data.append(row_data)
table_data.append(['mAP', '', '', '', '', '{:.3f}'.format(mean_ap[i])])
table = AsciiTable(table_data)
table.inner_footing_row_border = True
print(table.table)
def output_ascii_table(table_title=None,
table_data=None,
inner_heading_row_border=False,
inner_footing_row_border=False,
inner_row_border=False):
"""
@type table_title: unicode
@type table_data: list
@type inner_heading_row_border: bool
@type inner_footing_row_border: bool
@type inner_row_border: bool
"""
table = AsciiTable(table_data)
table.inner_heading_row_border = inner_heading_row_border
table.inner_row_border = inner_row_border
table.inner_footing_row_border = inner_footing_row_border
table.title = table_title
print(table.table)
def output_ascii_table(table_title=None,
table_data=None,
inner_heading_row_border=False,
inner_footing_row_border=False,
inner_row_border=False):
"""
@type table_title: unicode
@type table_data: list
@type inner_heading_row_border: bool
@type inner_footing_row_border: bool
@type inner_row_border: bool
"""
table = AsciiTable(table_data)
table.inner_heading_row_border = inner_heading_row_border
table.inner_row_border = inner_row_border
table.inner_footing_row_border = inner_footing_row_border
table.title = table_title
print(table.table)
def print_map_summary(mean_ap, results, dataset=None):
"""Print mAP and results of each class
Args:
mean_ap(float): calculated from `eval_map`
results(list): calculated from `eval_map`
dataset(None or str or list): get label names by dataset, see `cvbase.read_labels()`
"""
num_scales = len(results[0]['ap']) if isinstance(results[0]['ap'],
np.ndarray) else 1
num_classes = len(results)
recalls = np.zeros((num_scales, num_classes), dtype=np.float32)
precisions = np.zeros((num_scales, num_classes), dtype=np.float32)
aps = np.zeros((num_scales, num_classes), dtype=np.float32)
num_gts = np.zeros((num_scales, num_classes), dtype=int)
for i, cls_result in enumerate(results):
if cls_result['recall'].size > 0:
recalls[:, i] = np.array(cls_result['recall'], ndmin=2)[:, -1]
precisions[:, i] = np.array(cls_result['precision'], ndmin=2)[:,
-1]
aps[:, i] = cls_result['ap']
num_gts[:, i] = cls_result['num_gts']
try:
label_names = read_labels(dataset)
except:
label_names = range(1, num_classes + 1)
if not isinstance(mean_ap, list):
mean_ap = [mean_ap]
header = ['class', 'gts', 'dets', 'recall', 'precision', 'ap']
for i in range(num_scales):
table_data = [header]
for j in range(num_classes):
row_data = [
label_names[j], num_gts[i, j], results[j]['num_dets'],
'{:.3f}'.format(recalls[i, j]),
'{:.3f}'.format(precisions[i, j]), '{:.3f}'.format(aps[i, j])
]
table_data.append(row_data)
table_data.append(['mAP', '', '', '', '', '{:.3f}'.format(mean_ap[i])])
table = AsciiTable(table_data)
table.inner_footing_row_border = True
print(table.table)
def display_pull_stats(reviewers, reviewer_workload):
table_data = [
['Assignee', '# assigned'],
]
total = 0
for reviewer in reviewers:
workload = reviewer_workload[reviewer]
table_data.append(
[reviewer, six.text_type(workload)]
)
total += workload
table_data.append(['TOTAL: ', six.text_type(total)])
table = AsciiTable(table_data)
table.inner_footing_row_border = True
table.justify_columns = {1: 'center'}
print(table.table)
def print_results(results, use_color, outfile):
""" Print the given scan results """
table = AsciiTable([["File", "Type", "Code", "Line Number"]] + results)
table.justify_columns = {0: "center", 1: "center", 2: "left", 3: "center"}
table.inner_row_border = True
table.inner_footing_row_border = True
table.inner_heading_row_border = True
table.outer_border = True
output = table.table.split("\n")
output[2] = output[2].replace("-", "=")
print("\n".join(output) + "\n")
if outfile:
with open(outfile, "w") as f:
f.write("\n".join(output) + "\n")
my_print("[+] Analysis complete: %d suspicious code fragments found" %
len(results),
"blue",
use_color=use_color)
def get_category_table(ground_truth, predicted, categories=None, label=None):
if categories is None:
categories = [0, 1, 2, 4]
hits = {}
misses = {}
for value_pair in zip(ground_truth, predicted):
true_category = get_category(value_pair[0], categories)
predicted_category = get_category(value_pair[1], categories)
if true_category == predicted_category:
hits[true_category] = hits.get(true_category, 0) + 1
else:
misses[true_category] = misses.get(true_category, 0) + 1
table_data = [["Category", "Hits", "Misses", "Total"]]
cat_strings = get_category_strings(categories)
for i, category in enumerate(categories):
hit_count = hits.get(category, 0)
miss_count = misses.get(category, 0)
cat_str = cat_strings[i]
record = [
cat_str,
str(hit_count),
str(miss_count),
str(hit_count + miss_count)
]
table_data.append(record)
total_hits = sum(hits.values())
total_misses = sum(misses.values())
table_data.append([
"Total",
str(total_hits),
str(total_misses),
str(total_hits + total_misses)
])
table = Table(table_data)
table.title = "Categoric rating"
if label:
table.title += ": " + label
table.inner_footing_row_border = True
return table
def make_table(metric_name, header_name, metric_by_class, header_lst):
def _fill_table(fld, data, template='{:.03f}', avg=False):
if isinstance(fld, list) and len(fld) == len(data):
# Fill multiple rows.
rows = []
for idx in range(len(fld)):
rows += _fill_table(fld[idx], data[idx], template, avg)
return rows
else:
# Fill one row.
assert len(data.shape) == 1, \
'Invalid data shape: {}'.format(data.shape)
row = ['{}'.format(fld)]
row += map(lambda v: template.format(v), data.tolist())
if avg:
row += [template.format(data.mean())]
return [row]
title = '{} results on {}'.format(metric_name, cfg.DATASET)
tiou_row = _fill_table(header_name, tiou_thresh, template='{:.02f}')
tiou_row[0].append('Avg')
cls_rows = _fill_table(['{:d}'.format(c) for c in range(cfg.NUM_CLASSES)],
metric_by_class,
avg=True)
metric_avg = metric_by_class.mean(axis=0)
metric_row = _fill_table(metric_name, metric_avg, avg=True)
table_data = tiou_row + \
(cls_rows if cfg.EVAL.TBL_INCLUDE_CLS else []) + \
metric_row
table = AsciiTable(table_data, title)
table.justify_columns[-1] = 'right'
table.inner_footing_row_border = True
return table
def get_hosts(args):
try:
from terminaltables import AsciiTable
except ImportError:
AsciiTable = False
pass
response = requests.get(args.host + "/api/public/v1.0/groups/" +
args.group + "/hosts/",
auth=HTTPDigestAuth(args.username, args.apikey))
response.raise_for_status()
vprint("============= response ==============", args)
vprint(vars(response), args)
vprint("============= end response ==============", args)
hosts_json = response.json()
table_data = [[
'hostname', 'id', 'clusterId', 'version', 'typeName', 'replicaSetName',
'replicaStateName', 'lastPing'
]]
for host in hosts_json['results']:
row = []
for column in table_data[0]:
row.append(str(host.get(column)))
table_data.append(row)
table_data.append(
['', '', 'Number of hosts',
str(hosts_json['totalCount'])])
host_info = 'Hosts from ' + args.host
if AsciiTable:
table = AsciiTable(table_data, host_info)
table.inner_footing_row_border = True
print table.table
else:
import pprint
pprint.pprint(table_data)
def listSniffers(self):
"""
List avaialble sniffer
Usage: listSniffers
"""
table_data = [
["Idenfifier", "Name", "device(s)", "Protocol", "Is_alive"]
]
for s in self.sniffers.keys():
table_data.append([s, self.sniffers[s]['name'], self.sniffers[s]['thread'].device, self.sniffers[s]['protocol'], self.sniffers[s]['thread'].is_alive()])
table = AsciiTable(table_data)
table.inner_column_border = False
table.inner_footing_row_border = False
table.inner_heading_row_border = True
table.inner_row_border = False
table.outer_border = False
print (f'\nList of available sniffers:\n\n{table.table}\n')
def display_summary(Dict, num_classes):
"""Print metric results of each class.
Args:
Dict(dict(metric name=metric value))
num_classes
"""
header = []
for key, data in Dict.items():
header.append(key)
table_data = [header]
for j in range(num_classes):
row_data = []
for data in Dict.values():
if isinstance(data[j], (float, np.float32)):
str_data = '{:.4g}'.format(data[j])
elif isinstance(data[j], (int, np.int64, np.int32)):
str_data = '{:6d}'.format(data[j])
else:
str_data = '{:6s}'.format(str(data[j]))
row_data.append(str_data)
table_data.append(row_data)
mean = ['Mean']
for i, data in enumerate(Dict.values()):
if i == 0:
continue
if isinstance(data[0], (int, float, np.float32)):
ave = np.asarray(data).mean()
# else:
# ave = 0.0
mean.append('{:.4f}'.format(ave))
else:
mean.append(' --- ')
table_data.append(mean)
table = AsciiTable(table_data)
table.inner_footing_row_border = True
print(table.table)
# Add message to list
tmpdata.append(mess_deleted)
else :
# Add message to list
tmpdata.append("Google Agenda booked but ITEA calendar not")
# Add tmpdata list to myAsciiTable
myAsciiTable.append(tmpdata)
# Create AsciiTable and total
tmpdata = list()
tmpdata.append("Total : " + str(len(myAsciiTable) - 1) + " row(s)")
tmpdata.append("")
tmpdata.append("")
tmpdata.append("")
tmpdata.append("")
myAsciiTable.append(tmpdata)
myTable = AsciiTable(myAsciiTable)
myTable.inner_footing_row_border = True
myTable.justify_columns[1] = myTable.justify_columns[2] = myTable.justify_columns[3] = 'right'
# End script
time_stop = datetime.datetime.now()
time_delta = time_stop - time_start
# Output data
print "######### Date : %s - App : %s #########" % (time_start.strftime("%Y-%m-%d"),Config.get('GLOBAL','application'))
print "- Start time : %s" % (time_start.strftime("%Y-%m-%d %H:%M:%S"))
print "- Finish time : %s" % (time_stop.strftime("%Y-%m-%d %H:%M:%S"))
print "- Delta time : %d second(s)" % (time_delta.total_seconds())
print myTable.table