def print_llc():
total_llc_used = 0
total_llc_avg = 0
table = Texttable()
table.set_cols_align(["l", "r", "c", "c"])
table.set_cols_valign(["t", "m", "b", "b"])
rows = []
i = 1
rows.append([
"Seq",
get_color_string(bcolors.GREEN, "Instance-name"), "LLC / KB",
"LLC_AVG / KB"
])
for dom in dom_info.items():
rows.append([
i,
get_color_string(bcolors.BLUE, dom[1].name), dom[1].llc, dom[1].avg
])
total_llc_used += dom[1].llc
total_llc_avg += dom[1].avg
i = i + 1
rows.append([
'all',
get_color_string(bcolors.BLUE, "Total"), total_llc_used, total_llc_avg
])
table.add_rows(rows)
os.system('cls' if os.name == 'nt' else 'clear')
print(table.draw() + '\n')
def test_colored():
table = Texttable()
table.set_cols_align(["l", "r", "c"])
table.set_cols_valign(["t", "m", "b"])
table.add_rows([
[get_color_string(bcolors.GREEN, "Name Of Person"), "Age", "Nickname"],
["Mr\nXavier\nHuon", 32, "Xav'"],
[get_color_string(bcolors.BLUE,"Mr\nBaptiste\nClement"),
1,
get_color_string(bcolors.RED,"Baby")] ])
expected_output = dedent("""
+----------------+-----+----------+
| [92mName Of Person[0m | Age | Nickname |
+================+=====+==========+
| Mr | | |
| Xavier | 32 | |
| Huon | | Xav' |
+----------------+-----+----------+
| [94mMr[0m | | |
| [94mBaptiste[0m | 1 | |
| [94mClement[0m | | [91mBaby[0m |
+----------------+-----+----------+
""").strip('\n')
assert table.draw() == expected_output
def test_colored():
table = Texttable()
table.set_cols_align(["l", "r", "c"])
table.set_cols_valign(["t", "m", "b"])
table.add_rows([[
get_color_string(bcolors.GREEN, "Name Of Person"), "Age", "Nickname"
], ["Mr\nXavier\nHuon", 32, "Xav'"],
[
get_color_string(bcolors.BLUE,
"Mr\nBaptiste\nClement"), 1,
get_color_string(bcolors.RED, "Baby")
]])
expected_output = dedent("""
+----------------+-----+----------+
| [92mName Of Person[0m | Age | Nickname |
+================+=====+==========+
| Mr | | |
| Xavier | 32 | |
| Huon | | Xav' |
+----------------+-----+----------+
| [94mMr[0m | | |
| [94mBaptiste[0m | 1 | |
| [94mClement[0m | | [91mBaby[0m |
+----------------+-----+----------+
""").strip('\n')
assert table.draw() == expected_output
def _make_diff_row(cls, color, label, message):
label = texttable.get_color_string(color, label)
path = texttable.get_color_string(
texttable.bcolors.WHITE, message.path)
formatted_author = cls._format_author(message.deployed_by, True)
deployed = str(message.deployed).split('.')[0][
:-3] if message.deployed else ''
return [label, path, deployed, formatted_author]
def _make_diff_row(cls, color, label, message):
label = texttable.get_color_string(color, label)
path = texttable.get_color_string(
texttable.bcolors.WHITE, message.path)
formatted_author = cls._format_author(message.deployed_by, True)
deployed = str(message.deployed).split('.')[0][
:-3] if message.deployed else ''
return [label, path, deployed, formatted_author]
def present_c(self, c):
row = [
get_color_string(c, float2(self.kW)),
get_color_string(c, float2(self.Area)),
get_color_string(c, comma(float2(self.cost_sub))),
get_color_string(c, comma(float2(float(self.depri_amount)))),
get_color_string(c, comma(float2(self.bill_benefit))),
get_color_string(c, comma(float2(self.Rs_n_year))),
get_color_string(c, comma(float2(self.Final_amount))),
get_color_string(c, comma(float2(self.Savings))),
get_color_string(c, float2(self.int_rate)),
get_color_string(c, self.pay_back_period)
]
tab1.add_row(row)
class Board:
SIGNS = [
get_color_string(bcolors.RED, 'X'),
get_color_string(bcolors.BLUE, 'O')
]
def __init__(self):
self.board = []
self.create_board()
def create_board(self, width=3):
self.board.append([Square(str(i + 1)) for i in range(width)])
self.board.append([Square(str(i + 4)) for i in range(width)])
self.board.append([Square(str(i + 7)) for i in range(width)])
def check_win(self):
for i in range(3):
if self.board[0][i].sign == self.board[1][i].sign == self.board[2][
i].sign:
return True
if self.board[i][0].sign == self.board[i][1].sign == self.board[i][
2].sign:
return True
if self.board[0][0].sign == self.board[1][1].sign == self.board[2][
2].sign:
return True
if self.board[0][2].sign == self.board[1][1].sign == self.board[2][
0].sign:
return True
return False
def check_draw(self):
squares = []
for i in self.board:
for k in i:
squares.append(
k.sign) if k.sign in Board.SIGNS else squares.append('')
if all(squares):
return True
else:
return False
def __str__(self):
t = Texttable()
for row in self.board:
t.add_row(row)
return t.draw()
def __repr__(self):
t = Texttable()
for rowId in range(0,self.size[0]):
rowDetails = []
for cellId in range(0,self.size[1]):
cell = self.cellAtLocation(cellId,rowId)
color = {
"free": bcolors.WHITE,
"mine": bcolors.PURPLE,
"theirs": bcolors.RED
}[cell.getState()]
rowDetails.append(
get_color_string(color, cell)
)
t.add_row(rowDetails)
return "\n".join([
t.draw(),
self.board,
self.state
])
def print_results(results):
for message in results.test_results:
if message.result == messages.Result.PASS:
color = texttable.bcolors.GREEN
elif message.result == messages.Result.FAIL:
color = texttable.bcolors.GREEN
else:
color = texttable.bcolors.YELLOW
label = texttable.get_color_string(color, message.result)
logging.info('{} {}'.format(label, message.title))
def print_results(results):
for message in results.test_results:
if message.result == messages.Result.PASS:
color = texttable.bcolors.GREEN
elif message.result == messages.Result.FAIL:
color = texttable.bcolors.GREEN
else:
color = texttable.bcolors.YELLOW
label = texttable.get_color_string(color, message.result)
logging.info('{} {}'.format(label, message.title))
def print_nodes():
node_table = Texttable()
node_table.set_deco(Texttable.HEADER)
node_table.set_cols_align(["l", "l", "l", "l"])
node_rows = [["NAME", "ROLE", "STATUS", "OS"]]
for node_name in nodes_dict.keys():
node = nodes_dict[node_name]
status = ""
if node["status"] == "Ready":
status = get_color_string(bcolors.GREEN, node["status"])
else:
status = get_color_string(bcolors.RED, node["status"])
if node["unschedulable"]:
status = "%s,%s" % (
status, get_color_string(bcolors.YELLOW, "SchedulingDisabled"))
node_rows.append([node["name"], node["role"], status, node["osImage"]])
node_table.add_rows(node_rows)
print node_table.draw() + "\n\n"
def printc(c, string):
if (c == 'b'):
x = bcolors.BLUE
elif (c == 'r'):
x = bcolors.RED
elif (c == 'y'):
x = bcolors.YELLOW
elif (c == 'g'):
x = bcolors.GREEN
elif (c == 'w'):
x = bcolors.WHITE
print(get_color_string(x, string))
def PickSearchValue(self):
"""Select a value to be used in a search"""
if not self.presetvalues:
os.system('cls' if os.name == 'nt' else 'clear')
headerstrings = [
"Give a value the column {} should have.".format(
get_color_string(bcolors.BLUE, self.screenname)),
"- If you want to use a regex, surround the string with forward slashes (e.g. /^[m|M]yregexstri.*/)",
"- If this is a negative condition, begin the first condition with a ! (e.g. !dontmatchthis)",
"- Press l to load a list of values from an external file\n>"
]
value = input('\n'.join(headerstrings))
if value == 'l':
self.addmorevalues = False
return LoadCsv()
elif value[0] == '/' and value[-1] == '/':
self.addmorevalues = False
self.regexcond = True
return value.strip('/')
elif value[0] == '!' or self.negativeconds:
self.negativeconds = True
returnvalue = value[1:]
else:
returnvalue = value
else:
valuemenu = multimenu(
self.presetvalues,
'Pick a value the column {} should have '.format(
get_color_string(bcolors.BLUE, self.screenname)))
returnvalue = valuemenu.validanswers[valuemenu.answer]
self.askmoremenu.prompt_valid()
if self.askmoremenu.answer == 'y':
self.addmorevalues = True
else:
self.addmorevalues = False
return returnvalue
def print_node_pods():
for node_name in nodes_dict.keys():
node = nodes_dict[node_name]
pods_table = Texttable(0)
pods_table.set_deco(Texttable.HEADER)
pods_table.set_cols_align(["l", "r", "r", "r", "r", "r"])
pods_rows = [[
"NAME", "STATUS", "RESTART", "AGE", "TARGET PORT", "PORT"
]]
if len(node["pods"]) > 0:
for pod in node["pods"]:
status = ""
if pod["status"] == "Running":
status = get_color_string(bcolors.GREEN, pod["status"])
else:
status = get_color_string(bcolors.YELLOW, pod["status"])
pods_rows.append([
pod["name"], status, pod["restart_count"], pod["age"],
pod["target_port"], pod["port"]
])
pods_table.add_rows(pods_rows)
print node_name
print pods_table.draw() + "\n\n"
import subprocess
from itertools import chain
from texttable import Texttable, get_color_string, bcolors
def f(x):
if x=="quota_max_bytes":
return str(pool[x]/1024/1024)
else:
return str(pool[x])
p = subprocess.check_output('ceph osd dump -f json-pretty', shell=True)
pools = json.loads(p)['pools']
pools_table = Texttable()
header = [ "Id", "Pool", "Size", "Min_size", "Pg_num", "Pgp_num", "Crush","Quota (MB)", "Quota (obj)" ]
keys = [ "pool", "pool_name", "size", "min_size", "pg_num", "pg_placement_num", "crush_ruleset","quota_max_bytes","quota_max_objects" ]
pools_table.header(map(lambda x: get_color_string(bcolors.YELLOW, x), header))
for pool in pools:
pools_table.add_row(map(f, keys))
table = Texttable()
table.set_deco(Texttable.BORDER | Texttable.HEADER | Texttable.VLINES)
table.set_cols_align( [ "l", "l", "l", "l", "l", "l", "l" ])
table.set_cols_valign([ "m", "m", "m", "m", "m", "m", "m" ])
table.set_cols_width([ "20", "20", "8","8","20","8","8"])
header = [ "Pool", "Image", "Size(Mb)", "Features", "Lockers", "Str_size", "Str_cnt" ]
keys = [ "features", "list_lockers", "stripe_unit", "stripe_count" ]
table.header(map(lambda x: get_color_string(bcolors.YELLOW, x), header))
with rados.Rados(conffile='/etc/ceph/ceph.conf') as cluster:
pool_list = cluster.list_pools()
for pool in pool_list:
def purple_font(inp_text):
return get_color_string(bcolors.PURPLE, inp_text)
class Game:
SQUARES = {'1': [0, 0], '2': [0, 1], '3': [0, 2], '4': [1, 0], '5': [1, 1],
'6': [1, 2], '7': [2, 0], '8': [2, 1], '9': [2, 2]}
SIGNS = [get_color_string(bcolors.RED, 'X'), get_color_string(bcolors.BLUE, 'O')]
def __init__(self):
self.panel = Board()
self.human_player = Player(random.choice(Game.SIGNS))
self.computer_player = Player(Game.SIGNS[0] if self.human_player.sign == Game.SIGNS[1] else Game.SIGNS[1])
def print_board(self):
os.system('clear')
print(self.panel)
def start(self):
game_is_over = False
while not game_is_over:
self.print_board()
if self.computer_player.sign == Game.SIGNS[0]:
self.computer_turn()
self.player_turn()
else:
self.player_turn()
self.computer_turn()
def computer_turn(self):
coords = self.get_coordinates_of_blocking_position()
if not coords:
coords = random.choice(list(Game.SQUARES.values()))
while self.panel.board[coords[0]][coords[1]].sign in Game.SIGNS:
coords = random.choice(list(Game.SQUARES.values()))
self.panel.board[coords[0]][coords[1]] = Square(self.computer_player.sign)
time.sleep(1)
self.print_board()
if self.panel.check_win():
print('Computer win!')
sys.exit()
if self.panel.check_draw():
print('It is a draw!')
sys.exit()
def get_coordinates_of_blocking_position(self):
# Check horizontally
for k, v in enumerate(self.panel.board):
v = [i.sign for i in v]
if len(set(v)) < len(v):
for c, x in enumerate(v):
if x not in Game.SIGNS:
return k, c
# Check diagonally
v = [self.panel.board[k][k].sign for k in range(3)]
if len(set(v)) < len(v):
for c, x in enumerate(v):
if x not in Game.SIGNS:
return c, c
p = [self.panel.board[2][0].sign, self.panel.board[1][1].sign, self.panel.board[0][2].sign]
if len(set(p)) < len(p):
for i, j in zip(range(3), reversed(range(3))):
if self.panel.board[j][i].sign not in Game.SIGNS:
return j, i
# Check vertically
positions = []
for i in range(3):
positions.append([self.panel.board[k][i].sign for k in range(3)])
for i, v in enumerate(positions):
if len(set(v)) < len(v):
for c, x in enumerate(v):
if x not in Game.SIGNS:
return c, i
def player_turn(self):
sign_placed = False
while not sign_placed:
user_input = input('Select a space: ')
if user_input in Game.SQUARES.keys():
coords = Game.SQUARES[user_input]
else:
print('There is no such space!')
continue
if self.panel.board[coords[0]][coords[1]].sign not in Game.SIGNS:
self.panel.board[coords[0]][coords[1]] = Square(self.human_player.sign)
sign_placed = True
self.print_board()
if self.panel.check_win():
print('You win!')
sys.exit()
if self.panel.check_draw():
print('It is a draw!')
sys.exit()
else:
print('Space is already taken!')
def check_draw(self):
squares = []
for i in self.panel.board:
for k in i:
squares.append(k.sign) if k.sign in Game.SIGNS else squares.append('')
if all(squares):
return True
else:
return False
def command_map(self, params):
'''[<add/list/delete/update>] [<param.1> ... <param.n>]
list/update/add mappings between VM name and PDU port
map add <datastore> <vm> <pdu> <port>
- Add an entry for VM and vPDU port
e.g.:
Add an entry.
map add datastore1 vquanta_auto1 1 2
map update <datastore> <vm> <pdu> <port>
- update an entry for VM and vPDU port
e.g.:
Update an existing datastore entry
map update datastore1 vquanta_auto1 3 1
map delete <datastore> <vm>
- Delete a datastore or a mapping for vm
e.g.:
Delete "datastore1"
map delete datastore1
Delete a mapping "vquanta_auto1 = 2" in datastore1
map delete datastore1 vquanta_auto1
map list
- List all mappings between VMs and vPDU ports
Note: when you are done to make changes, please run 'map list' to be
sure eveything is correct.
'''
if len(params) == 0:
return
if params[0] == "add" or params[0] == "update":
if len(params) != 5:
self.writeresponse(
colors.RED + "Invalid parameters." + colors.NORMAL
)
return
self.mapping_file_handle.update(params[1], params[2],
params[3], params[4])
elif params[0] == "delete":
if len(params) == 2:
self.mapping_file_handle.delete(params[1])
elif len(params) == 3:
self.mapping_file_handle.delete(params[1], params[2])
else:
self.writeresponse("Invalid parameters.")
elif params[0] == "list":
table = Texttable()
table.header(["PDU", "Port", "VM Name", "Datastore"])
table.set_cols_align(['c', 'c', 'c', 'c'])
for node_list in self.mapping_file_handle.nodes_list:
datastore = node_list.keys()[0]
for ni in node_list[datastore]:
table.add_row([
get_color_string(bcolors.GREEN, ni["control_pdu"]),
get_color_string(bcolors.GREEN, ni["control_port"]),
get_color_string(bcolors.GREEN, ni['node_name']),
get_color_string(bcolors.GREEN, datastore)
])
self.writeresponse(table.draw())
def generate_report(year=None, quarter=None):
dir = os.path.dirname(__file__)
config = ConfigParser()
config.read(os.path.join(dir, 'config.cfg'))
report = SortedDict()
gbif = gbif_downloads()
for date_str, downloads in gbif.items():
m, y = map(int, date_str.split('-'))
if year and y != year:
continue
if quarter and m not in quarter_months[quarter]:
continue
report_add_entry(report, y, m, 'gbif_records', downloads['records'])
report_add_entry(report, y, m, 'gbif_download_events', downloads['download_events'])
last_timestamp = 0
# Load the legacy data
# This has been derived from redis/celery task queue
# Which is how we did things before storing the download count in the
# ckanpackager stats.db
with open(os.path.join(dir, 'src', 'legacy.json')) as data_file:
data = json.load(data_file)
for row in data:
ts = timestring.Date(row['date'])
# We want to know what the last timestamp is
if ts.to_unixtime() > last_timestamp:
last_timestamp = ts.to_unixtime()
process_row(report, year, quarter, ts, row.get('resource_id'), row.get('count', None))
db = config.get('sqlite', 'db')
if not os.path.isfile(db):
raise IOError('Stats.db does not exist')
conn = sqlite3.connect(db)
# Retrieve all requests received after the last entry in the legacy data
requests = conn.execute("SELECT * FROM requests WHERE timestamp > '%s'" % last_timestamp)
# Loop through requests, adding them to the stats
for request in requests:
resource_id = request[2]
ts = datetime.datetime.fromtimestamp(request[3])
count = int(request[4]) if request[4] else None
process_row(report, year, quarter, ts, resource_id, count)
header = OrderedDict([
('collection_records', 'Collection records'),
('other_records', 'Other records'),
('gbif_records', 'GBIF records'),
('collection_download_events', 'Collection download events'),
('other_download_events', 'Other download events'),
('gbif_download_events', 'GBIF download events'),
])
table = Texttable()
table.set_deco(Texttable.HEADER)
rows = []
totals = OrderedDict([(k, 0) for k in header.keys()])
for year, months in report.items():
if len(rows) == 0:
rows.append(['Month'] + header.values())
for month, items in months.items():
row = [get_color_string(bcolors.GREEN, '%s %s' % (calendar.month_abbr[month], str(year)[2:4]))]
for key in header.keys():
row.append(str(items.get(key, '')))
# Update totals
totals[key] += items.get(key, 0)
rows.append(row)
rows.append([get_color_string(bcolors.YELLOW, str(t)) for t in ['Totals'] + totals.values()])
table.add_rows(rows)
print(table.draw())
def colored_table_entry(entry, bcolor): return get_color_string(bcolor, entry)
def my_rows(row, selected_columns, df):
print(f'selected_columns {selected_columns}')
# row = [1, 3, 5, 6]
# selected_columns = [2, 3]
# selected_columns = []
# Get columns headers
index = len(df.index)
# print(f'index: {index}')
columns = list(df.columns)
columns_index = len(columns)
# print(f'columns_index: {columns_index}')
# Determine to use selected_columns or all_columns
if selected_columns == 'all':
the_columns = range(1, columns_index + 1)
else:
the_columns = selected_columns
header_list = []
row_list = []
row_group = []
row_info_rows = []
group = []
results = []
# Build 1st Column of table
row_info_rows.append('Row / Col')
# for each row
for i in row:
# first row
if i == 1:
header_list = df.loc[i, columns].tolist()
# next row
else:
row_list = df.loc[i-2, columns].tolist()
row_group.append(row_list)
row_info_rows.append(str(i)) # Build 1st Column of table
row_info_rows.append('Results') # Build 1st Column of table
# print(row_info_rows)
results.append(row_info_rows)
col_results = []
col_r = []
for i, lista in enumerate(row_group):
if i == 0:
# for column_i in range(1, columns_index + 1):
for column_i in the_columns:
col = column_i - 1
for header_i, header in enumerate(columns):
if col == header_i:
col_r.append(header)
col_r.append(lista[col])
for ii, lista2 in enumerate(row_group):
if i != ii:
col_r.append(lista2[col])
set_col_r = set(col_r[1:])
if len(set_col_r) == 1:
print(set_col_r)
col_r.append('-')
if len(set_col_r) > 1:
print(set_col_r)
col_r.append(get_color_string(bcolors.RED,"diff"))
print('group')
print(group)
# group.append(col_r)
results.append(col_r)
# print(results)
col_r = []
print(f'------------ rows ------------------')
tab = tt.Texttable()
tab.set_deco(tab.HEADER)
for row in zip(*results):
tab.add_row(row)
s = tab.draw()
print(s, '\n')
def check_row_pairs(sel_row, sel_col, file):
filename = file
df = pd.read_csv(filename)
# Get columns headers
index = len(df.index)
columns = list(df.columns)
columns_index = len(columns)
new_list = []
old_list = []
group = []
results = []
row_group = []
# row_info_rows = []
row_old = ''
row_new = ''
for i, data in enumerate(sel_row):
# first row
if i == 0:
old_list = df.loc[data - 2, columns].tolist()
# print(f'old list {old_list}')
row_old = data
# row_old = i
# pass # ??? does it need to check i==0 ???
# next rows
else:
# if i in sel_row:
# print(f'old list {old_list}')
new_list = df.loc[data - 2, columns].tolist()
row_group.append(new_list)
# print(f'new_list {new_list}')
row_new = data
# print(f'old1 {row_old} new {row_new}')
group = []
# for each column
for ii, old in enumerate(old_list):
# append first row of columns to group
if len(group) == 0:
row_info = ['Row / Col', row_old, row_new, 'Result']
group.append(row_info)
# print(group)
# compare column, same values
if old == new_list[ii]:
# print(f'SAME old {old} row_group {row_group}')
col = [columns[ii], old, new_list[ii], '-']
# compare column, different values
else:
col = [columns[ii], old, new_list[ii], get_color_string(bcolors.RED,"diff")]
# print(f'DIFF old {old} new_list {new_list[ii]}')
# print(f'col {col}')
group.append(col)
# add group to results and reset the lists
if ii == (columns_index - 1):
results.append(group)
# clean lists
new = []
group = []
# # re-assign rows to old
old_list = new_list
row_old = row_new
# print(f'old2 {row_old} new {row_new}')
print(f'------------ table ------------------')
for group in results:
tab = tt.Texttable()
# tab.header(columns_name)
# tab.set_deco(tt.Texttable.BORDER |
# tt.Texttable.HEADER |
# tt.Texttable.VLINES)
tab.set_deco(tab.HEADER)
for row in zip(*group):
# print(row)
tab.add_row(row)
s = tab.draw()
print(s, '\n')
def draw_table(k8shpa_list, alameda_list, nonhpa_list):
print "\n"
# title
table = []
row = line()
table.append(row)
row = [
texttable.get_color_string(
texttable.bcolors.GREEN,
"Summary of Apache Benchmark for Kubernetes Native and Federator.ai"
)
]
table.append(row)
row = line()
table.append(row)
ttable = texttable.Texttable()
ttable.set_cols_align(["c"])
ttable.add_rows(table)
print ttable.draw()
metrics_list = ["avg. time per request"]
if show_details:
metrics_list = k8shpa_list.keys()
# context
table = []
row = line_row(show_details)
table.append(row)
if nonhpa_list and show_details:
row = ["", " ", " ", " ", "\n"]
row[0] = "Metrics"
row[1] = "OverProvision"
row[2] = "K8sHPA"
row[3] = "Federator.ai"
row[4] = "Comparison"
else:
row = ["", " ", " ", "\n"]
row[0] = "Metrics"
row[1] = "K8sHPA"
row[2] = "Federator.ai"
row[3] = "Comparison"
table.append(row)
for metrics in sorted(metrics_list):
row = line_row(show_details)
table.append(row)
if nonhpa_list and show_details:
row = ["", " ", " ", " ", "\n"]
else:
row = ["", " ", " ", "\n"]
k8shpa = round(
sum(k8shpa_list[metrics]) * 1.0 / len(k8shpa_list[metrics]), 2)
alameda = round(
sum(alameda_list[metrics]) * 1.0 / len(alameda_list[metrics]), 2)
row[0] = texttable.get_color_string(texttable.bcolors.BOLD, metrics)
if show_details:
nonhpa = round(
sum(nonhpa_list[metrics]) * 1.0 / len(nonhpa_list[metrics]), 2)
row[1] = str(nonhpa)
row[2] = str(k8shpa) + "\n" + "(" + str(
k8shpa_list[metrics])[1:-1] + ")"
row[3] = str(alameda) + "\n" + "(" + str(
alameda_list[metrics])[1:-1] + ")"
else:
row[1] = str(k8shpa)
row[2] = str(alameda)
if k8shpa == 0:
k8shpa = 1
value = round((k8shpa - alameda) / k8shpa * 100, 2)
if metrics.find("complete requests") != -1 or metrics.find(
"requests per second") != -1:
value = round((alameda - k8shpa) / k8shpa * 100, 2)
if value < 0:
if show_details:
row[4] = str(value) + "%"
else:
row[3] = str(value) + "%"
elif value > 0:
if show_details:
row[4] = str(value) + "%"
else:
row[3] = str(value) + "%"
else:
if show_details:
row[4] = str(value)
else:
row[3] = str(value)
table.append(row)
row = line_row(show_details)
table.append(row)
ttable = texttable.Texttable()
if show_details:
ttable.set_cols_align(["l", "c", "c", "c", "c"])
else:
ttable.set_cols_align(["l", "c", "c", "c"])
ttable.add_rows(table)
print ttable.draw()
return ttable.draw
class MainMenu:
"""This class include all
the comand line menu options and actions"""
mainanswers = {
'q': 'quit',
'2': 'select language',
'3': 'Toggle parallel search on/off',
'1': 'select database',
'5': 'View searches',
'6': 'View saved searches',
'7': 'Corpus stats',
'4': get_color_string(bcolors.RED, 'Concordances')
}
def __init__(self):
self.menu = multimenu(MainMenu.mainanswers)
# Selectable options:
self.selectedlang = 'none'
self.selecteddb = 'none'
self.isparallel = 'no'
self.searchcommitted = False
self.columns = dict()
#Control the program flow
self.run = True
self.pause = False
self.conditionset = None
def runmenu(self):
'Run the main menu'
#If all necessary prerequisites are set, initialize the possible conditions
#Clear the terminal:
os.system('cls' if os.name == 'nt' else 'clear')
#Build the selected options
self.menu.question = 'Welcome\n\n' + '='*40 + \
'''\n\nSelected options:
\nDatabase: {db}\nLanguage: {lang} \nParallel Concordances: {parc} {wspace}
'''.format(db=self.selecteddb,lang=self.selectedlang, parc=self.isparallel, wspace='\n'*2 + '='*40 + '\n'*2)
self.menu.validanswers = MainMenu.mainanswers
self.menu.prompt_valid()
self.MenuChooser(self.menu.answer)
#Show language if selected:
def chooselang(self):
self.menu.question = 'Select language: '
self.menu.validanswers = {'f': 'finnish', 'r': 'russian'}
self.menu.prompt_valid()
#Evaluate:
if self.menu.answer == 'f':
Db.searched_table = 'fi_conll'
self.selectedlang = 'fi'
elif self.menu.answer == 'r':
Db.searched_table = 'ru_conll'
self.selectedlang = 'ru'
if self.selecteddb != 'none':
print('Initializing configuration...')
self.conditionset = ConditionSet(self.selecteddb)
def choosedb(self):
self.menu.question = 'Select database: '
self.menu.validanswers = {
'1': 'syntparfin2',
'2': 'syntparrus2',
'3': 'russian_ext',
'4': 'tbcorpfi',
'5': 'tbcorpfinnish'
}
self.menu.prompt_valid()
Db.con = mydatabase(self.menu.validanswers[self.menu.answer], 'juho')
self.selecteddb = self.menu.validanswers[self.menu.answer]
if self.selectedlang != 'none':
print('Initializing configuration...')
self.conditionset = ConditionSet(self.selecteddb)
def testSettings(self):
if self.selecteddb == 'none':
return input('Please select a database first!')
if self.selectedlang == 'none':
return input('Please select a language first!')
return True
def Parconc(self):
"""The actual concordancer"""
if self.testSettings():
if self.searchcommitted:
self.conditionset.ResetConditions()
self.conditionset.AddConditions()
parallelon = False
if self.isparallel == 'yes':
parallelon = True
# addheadcond = input('Press enter to move on, h to add conditions concerning the head of the matching word')
# if addheadcond == 'h':
# self.conditionset.AddConditions(headcond=True)
if parallelon:
self.search = makeSearch(
database=Db.con.dbname,
dbtable=Db.searched_table,
ConditionColumns=self.conditionset.condcols,
headcond=self.conditionset.headcols,
isparallel=parallelon)
else:
self.search = makeSearch(
database=Db.con.dbname,
dbtable=Db.searched_table,
ConditionColumns=self.conditionset.condcols,
headcond=self.conditionset.headcols,
isparallel=parallelon,
monoling=True)
printResults(self.search)
self.searchcommitted = True
def viewsearches(self):
"""Take a look at the conducted searches and repeat / save them"""
#collect the answers in a dict
answlist = dict()
for idx, searchobject in enumerate(Search.all_searches):
answlist[str(idx)] = searchobject.name
answlist['c'] = "Cancel"
try:
pickedsearch = Search.all_searches[int(
self.menu.redifine_and_prompt('Select a search', answlist))]
self.menu.redifine_and_prompt(
'What do you want to do with this search?', {
's': 'save',
'r': 're-show the results'
})
if self.menu.answer == 's':
filename = "savedsearches/{}_{}.p".format(
pickedsearch.name, datetime.date.today())
pickedsearch.filename = filename
filenumber = 2
while os.path.exists(filename):
filename = "savedsearches/{}_{}{}.p".format(
pickedsearch.name, datetime.date.today(), filenumber)
pickedsearch.filename = filename
filenumber += 1
pickle.dump(pickedsearch, open(filename, "wb"))
elif self.menu.answer == 'r':
printResults(pickedsearch)
except:
pass
def viewsavedsearches(self):
"""Take a look at the saved searches and append them to the lsit of searches"""
#collect the answers in a dict
answlist = dict()
if glob.glob('savedsearches/*.p'):
for idx, savedsearch in enumerate(glob.glob('savedsearches/*.p')):
answlist[str(idx)] = savedsearch
answlist['c'] = "Cancel"
pickedsearch = answlist[self.menu.redifine_and_prompt(
'Load a saved search:', answlist)]
try:
Search.all_searches.append(loadpickle(pickedsearch))
print(
'Search {} loaded succesfully. Press "View searches" in the main menu to view it'
.format(pickedsearch))
except:
print('No search loaded')
else:
print('No saved searches found.')
def MenuChooser(self, answer):
os.system('cls' if os.name == 'nt' else 'clear')
if answer == 'q':
self.run = False
elif answer == '2':
self.chooselang()
elif answer == '1':
self.choosedb()
elif answer == '3':
if self.isparallel == 'no':
self.isparallel = 'yes'
else:
self.isparallel = 'no'
elif answer == '5':
self.viewsearches()
self.pause = True
elif answer == '6':
self.viewsavedsearches()
elif answer == '4':
self.pause = True
self.Parconc()
elif answer == '7':
statmen = Statmenu()
statmen.runmenu()
def ListColumns(self):
if not self.columns:
psycon = psycopg(self.selecteddb, 'juho')
rows = psycon.FetchQuery(
'SELECT column_name FROM information_schema.columns WHERE table_name = %s',
(Db.searched_table, ))
for idx, row in enumerate(rows):
self.columns[str(idx)] = row[0]
else:
return str(pool[x])
p = subprocess.check_output('ceph osd dump -f json-pretty', shell=True)
pools = json.loads(p)['pools']
pools_table = Texttable()
header = [
"Id", "Pool", "Size", "Min_size", "Pg_num", "Pgp_num", "Crush",
"Quota (MB)", "Quota (obj)"
]
keys = [
"pool", "pool_name", "size", "min_size", "pg_num", "pg_placement_num",
"crush_ruleset", "quota_max_bytes", "quota_max_objects"
]
pools_table.header(map(lambda x: get_color_string(bcolors.YELLOW, x), header))
for pool in pools:
pools_table.add_row(map(f, keys))
table = Texttable()
table.set_deco(Texttable.BORDER | Texttable.HEADER | Texttable.VLINES)
table.set_cols_align(["l", "l", "l", "l", "l", "l", "l"])
table.set_cols_valign(["m", "m", "m", "m", "m", "m", "m"])
table.set_cols_width(["20", "20", "8", "8", "20", "8", "8"])
header = [
"Pool", "Image", "Size(Mb)", "Features", "Lockers", "Str_size", "Str_cnt"
]
keys = ["features", "list_lockers", "stripe_unit", "stripe_count"]
table.header(map(lambda x: get_color_string(bcolors.YELLOW, x), header))
with rados.Rados(conffile='/etc/ceph/ceph.conf') as cluster:
def printResults(thisSearch):
if len(thisSearch.matches) > 0:
printcount = input(
'Found {} occurences. How many should I print? (press enter to print all)\n'
.format(thisSearch.absolutematchcount))
if printcount == '':
printcount = thisSearch.absolutematchcount
else:
printcount = int(printcount)
while printcount > thisSearch.absolutematchcount:
printcount = int(
input('Please give a number smaller than {}.'.format(
thisSearch.absolutematchcount + 1)))
ordermenu = multimenu({
'r': 'randomize',
'n': 'Do not randomize'
}, 'Should I randomize the order?')
if ordermenu.answer == 'r':
randomkeys = random.sample(list(thisSearch.matches), printcount)
printmatches = list()
for rkey in randomkeys:
alignsegment = thisSearch.matches[rkey]
#randomly select 1 of the matches in this segment
printmatches.append(random.choice(alignsegment))
else:
printmatches = list()
for align_id, matches in thisSearch.matches.items():
for match in matches:
if len(printmatches) < printcount:
printmatches.append(match)
else:
break
#actual printing
#========================================
csvrows = list()
rows = list()
table = Texttable()
#Initialize table printer
table.set_cols_align(["l", "l"])
table.set_cols_valign(["m", "m"])
if thisSearch.isparallel:
headerrow = ['sl', 'tl', 'source']
else:
headerrow = ['concordance', 'source']
csvrows = [headerrow]
for idx, match in enumerate(printmatches):
match.BuildSlContext()
if thisSearch.isparallel:
match.BuildTlContext()
rows.append([
'Source text id: {}, Sentence id: {}, align id: {}\n'.
format(match.matchedword.sourcetextid,
match.matchedsentence.sentence_id, match.align_id),
''
])
rows.append([
get_color_string(bcolors.BLUE, match.slcontextstring),
get_color_string(bcolors.RED, match.tlcontextstring)
])
csvrows.append([
match.slcontextstring, match.tlcontextstring,
match.matchedword.sourcetextid
])
else:
if len(match.slcontextstring) > 3000:
printedstring = match.matchedsentence.printstring + "(only sentence printed)"
else:
printedstring = match.slcontextstring
print(
'{}:\n=======================\n{}\n----------------------\n[Sentence id: {}, align id: {}, text_id: {}]\n\n\n'
.format(idx, textwrap.fill(printedstring),
match.matchedsentence.sentence_id, match.align_id,
match.matchedword.sourcetextid))
csvrows.append(
[match.slcontextstring, match.matchedword.sourcetextid])
if thisSearch.isparallel:
table.add_rows(rows)
print(table.draw() + "\n")
#========================================
csvmenu = multimenu({'y': 'yes', 'n': 'no'}, 'Save csv?', False)
if csvmenu.answer == 'y':
fname = input('Give the name of the csv:\n>')
with open(fname, "w", newline='') as f:
writer = csv.writer(f)
try:
writer.writerows(csvrows)
except TypeError:
import ipdb
ipdb.set_trace()
else:
print('Sorry, nothing found.')
print(thisSearch.subquery)
print(thisSearch.subqueryvalues)
def check_row_pairs(sel_row, sel_col, sel_find, file):
sel_find = sel_find
filename = file
df = pd.read_csv(filename)
# Get columns headers
index = len(df.index)
# Get only the selected columns
columns = []
for i in sel_col:
columns.append(df.columns[i-1])
# !!! Test find in columns
# print('___')
# print(df.columns.str.contains("A|C")==True)
columns_index = len(columns)
new_list = []
old_list = []
group = []
results = []
row_group = []
row_old = ''
row_new = ''
for i, data in enumerate(sel_row):
# first row
if i == 0:
# pass # ??? does it need to check i==0 ???
old_list = df.loc[data - 2, columns].tolist()
row_old = data # row number
# !!! Test searching
# print(df.loc[data - 2, columns].str.contains("aaa6|aaa4")==True)
# next rows
else:
new_list = df.loc[data - 2, columns].tolist()
row_group.append(new_list)
row_new = data # row number
# !!! Test find in columns
# print(df.loc[data - 2, columns].str.contains("dddd")==True)
# Group of rows. ie. #2 and #3, #3 and #4...
group = []
# for each column
for ii, old in enumerate(old_list):
# Fill empty cells with <EMPTY> to allow difflib.ndiff
if type(old) == type(0.1):
old = '<EMPTY>'
if type(new_list[ii]) == type(0.1):
new_list[ii] = '<EMPTY>'
# append first row of columns to group
if len(group) == 0:
row_info = ['Row / Col', row_old, row_new, 'Result']
group.append(row_info)
# compare each column, same values on temp list "col"
if old == new_list[ii]:
col = [columns[ii], old, new_list[ii], '-']
# compare column, different values
else:
# Test to apply color in 1 word
br = f'{redb}{whitef}{bold}{new_list[ii]}{reset}'
col = [columns[ii], old, br, get_color_string(bcolors.RED,"diff")]
a = old
b = new_list[ii]
# 1st row formatting: apply color for each different character
abc = ''
for iii, s in enumerate(difflib.ndiff(b, a)):
if s[0]==' ':
abc = abc + s[-1]
elif s[0]=='-':
br_color = f'{redb}{whitef}{bold}{s[-1]}{reset}'
elif s[0]=='+':
br_color = f'{redb}{whitef}{bold}{s[-1]}{reset}'
abc = abc + br_color
# Assign wrong characters colored in red
col[1] = abc
# 2nd row formatting: apply color for each different character
abc = ''
for iii, s in enumerate(difflib.ndiff(a, b)):
if s[0]==' ':
abc = abc + s[-1]
elif s[0]=='-':
br_color = f'{redb}{whitef}{bold}{s[-1]}{reset}'
elif s[0]=='+':
br_color = f'{redb}{whitef}{bold}{s[-1]}{reset}'
abc = abc + br_color
# Assign wrong characters colored in red
col[2] = abc
for col_index, col_item in enumerate(col):
if 'aaa4' == col_item:
col[col_index] = get_color_string(bcolors.GREEN, col_item)
# print(f'col {col}')
group.append(col)
# add group to results and reset the lists
if ii == (columns_index - 1):
results.append(group)
# clean lists
new = []
group = []
# Re-assign new list and index to old list and index
old_list = new_list # List with row values
row_old = row_new # Variable with row number value
print(f'------------ table ------------------')
for group in results:
tab = tt.Texttable()
tab.set_deco(tab.HEADER)
for row in zip(*group):
tab.add_row(row)
s = tab.draw()
print(s, '\n')
def command_config(self, params):
'''<esxi|pdu> [<list/update/add/delete> | <set/get>] [<param.1> ... < param.n>]
configure vPDU
----------------------------------
config pdu set <name>
- set PDU name
e.g.
config pdu set hawk
config pdu set database <database file>
- set pdu database file name
e.g.
config pdu set database ipia.db
config pdu set datadir <snmp data dir>
- set snmp data directory name
e.g.
config pdu set datadir hawk
config pdu list
-list pdu configurations
config esxi
--------------------------------------
config esxi list
- list configuration
config esxi update <option name> <value>
- update configuration
e.g.
Update esxi ip address in configuration file, run below command:
config esxi update host 10.62.59.124
Update esxi host "username"
config esxi update uesrname root
Update esxi host "password"
config esxi update password root
config esxi add <host> <uesrname> <password>
- add configuration
e.g.
Add an ESXi host information including ip, username and passowrd
config esxi add 10.62.59.128 root 1234567
config esxi delete
- delete configuration
e.g.
Delete section "esxihost"
config esxi delete esxihost
Note: After update/add the configuration, please run 'config list' to
be sure that the changes you made are correct.
'''
if len(params) == 0:
return
if params[0] == "pdu":
if params[1] == 'set':
if params[2] == 'name':
self.config_instance.pdu_name = params[3]
elif params[2] == 'database':
self.config_instance.db_file = params[3]
elif params[2] == 'datadir':
self.config_instance.snmp_data_dir = params[3]
self.config_instance.update()
elif params[1] == 'get':
self.config_instance.init()
table = Texttable()
table.add_row(['name', self.config_instance.pdu_name])
table.add_row(['database', self.config_instance.db_file])
table.add_row(['snmp data dir',
self.config_instance.snmp_data_dir])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
elif params[1] == 'list':
self.config_instance.init()
table = Texttable()
table.add_row(['pdu name', self.config_instance.pdu_name])
table.add_row(['dbtype', self.config_instance.db_type])
table.add_row(['database', self.config_instance.db_file])
table.add_row(['snmpdata', self.config_instance.snmp_data_dir])
table.add_row(['simfile', self.config_instance.sim_file])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
else:
logger.error("Unknown command {0}".format(params[0]))
elif params[0] == "esxi":
if params[1] == "list":
self.config_instance.init()
esxi_info = self.config_instance.esxi_info
if esxi_info is not None:
table = Texttable()
table.header(["esxi host", "username", "password"])
table.add_row([
get_color_string(bcolors.GREEN, esxi_info['host']),
get_color_string(bcolors.GREEN, esxi_info["username"]),
get_color_string(bcolors.GREEN, esxi_info['password'])
])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
return
else:
self.writeresponse("%sNo ESXi host info in configuration \
file.%s" % (colors.RED, colors.NORMAL))
elif params[1] == "update":
if len(params[2:]) == 2:
esxi_info = self.config_instance.esxi_info
if esxi_info is not None:
esxi_info[params[2]] = params[3]
self.config_instance.update()
else:
self.writeresponse("%sNo %s found in configuration \
file.%s" % (colors.RED, params[1], colors.NORMAL))
elif params[1] == "add":
if len(params[2:]) != 3:
return
if self.config_instance.esxi_info is None:
esxi_info = {}
logger.info("Adding esxi host: {0}, {1}, {2}"
.format(params[2], params[3], params[4]))
esxi_info['host'] = params[2]
esxi_info['username'] = params[3]
esxi_info['password'] = params[4]
self.config_instance.esxi_info = esxi_info
self.config_instance.update()
else:
self.writeresponse("ESXi info already exists.")
elif params[1] == "delete":
if self.config_instance.esxi_info is not None:
self.config_instance.delete()
else:
self.writeresponse("ESXi info already deleted.")
else:
self.writeresponse("unknown parameters.")
else:
self.writeresponse("unknown parameters: {0}.".format(params[0]))
def green_font(inp_text):
return get_color_string(bcolors.GREEN, inp_text)
from texttable import Texttable, get_color_string, bcolors
table = Texttable()
table.set_cols_align(["l", "r", "c"])
table.set_cols_valign(["t", "m", "b"])
table.add_rows([
[get_color_string(bcolors.GREEN, "Name Of Person"), "Age", "Nickname"],
["Mr\nXavier\nHuon", 32, "Xav'"],
[get_color_string(bcolors.BLUE,"Mr\nBaptiste\nClement"),
1,
get_color_string(bcolors.RED,"Baby")] ])
print(table.draw() + "\n")
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_cols_dtype(['t', # text
'f', # float (decimal)
'e', # float (exponent)
'i', # integer
'a']) # automatic
table.set_cols_align(["l", "r", "r", "r", "l"])
table.add_rows([["text", "float", "exp", "int", "auto"],
["abcd", "67", 654, 89, 128.001],
["efghijk", 67.5434, .654, 89.6, 12800000000000000000000.00023],
["lmn", 5e-78, 5e-78, 89.4, .000000000000128],
["opqrstu", .023, 5e+78, 92., 12800000000000000000000]])
print(table.draw())
def red_font(inp_text):
return get_color_string(bcolors.RED, inp_text)
def command_config(self, params):
'''<esxi|pdu> [<list/update/add/delete> | <set/get>] [<param.1> ... < param.n>]
configure vPDU
----------------------------------
config pdu set <name>
- set PDU name
e.g.
config pdu set hawk
config pdu set database <database file>
- set pdu database file name
e.g.
config pdu set database ipia.db
config pdu set datadir <snmp data dir>
- set snmp data directory name
e.g.
config pdu set datadir hawk
config pdu list
-list pdu configurations
config esxi
--------------------------------------
config esxi list
- list configuration
config esxi update <option name> <value>
- update configuration
e.g.
Update esxi ip address in configuration file, run below command:
config esxi update host 10.62.59.124
Update esxi host "username"
config esxi update uesrname root
Update esxi host "password"
config esxi update password root
config esxi add <host> <uesrname> <password>
- add configuration
e.g.
Add an ESXi host information including ip, username and passowrd
config esxi add 10.62.59.128 root 1234567
config esxi delete
- delete configuration
e.g.
Delete section "esxihost"
config esxi delete esxihost
Note: After update/add the configuration, please run 'config list' to
be sure that the changes you made are correct.
'''
if len(params) == 0:
return
if params[0] == "pdu":
if params[1] == 'set':
if params[2] == 'name':
self.config_instance.pdu_name = params[3]
elif params[2] == 'database':
self.config_instance.db_file = params[3]
elif params[2] == 'datadir':
self.config_instance.snmp_data_dir = params[3]
self.config_instance.update()
elif params[1] == 'get':
self.config_instance.init()
table = Texttable()
table.add_row(['name', self.config_instance.pdu_name])
table.add_row(['database', self.config_instance.db_file])
table.add_row(['snmp data dir',
self.config_instance.snmp_data_dir])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
else:
logger.error("Unknown command {0}".format(params[0]))
elif params[0] == "esxi":
if params[1] == "list":
self.config_instance.init()
esxi_info = self.config_instance.esxi_info
if esxi_info is not None:
table = Texttable()
table.header(["esxi host", "username", "password"])
table.add_row([
get_color_string(bcolors.GREEN, esxi_info['host']),
get_color_string(bcolors.GREEN, esxi_info["username"]),
get_color_string(bcolors.GREEN, esxi_info['password'])
])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
return
else:
self.writeresponse("%sNo ESXi host info in configuration \
file.%s" % (colors.RED, colors.NORMAL))
elif params[1] == "update":
if len(params[2:]) == 2:
esxi_info = self.config_instance.esxi_info
if esxi_info is not None:
esxi_info[params[2]] = params[3]
self.config_instance.update()
else:
self.writeresponse("%sNo %s found in configuration \
file.%s" % (colors.RED, params[1], colors.NORMAL))
elif params[1] == "add":
if len(params[2:]) != 3:
return
if self.config_instance.esxi_info is None:
esxi_info = {}
logger.info("Adding esxi host: {0}, {1}, {2}"
.format(params[2], params[3], params[4]))
esxi_info['host'] = params[2]
esxi_info['username'] = params[3]
esxi_info['password'] = params[4]
self.config_instance.esxi_info = esxi_info
self.config_instance.update()
else:
self.writeresponse("ESXi info already exists.")
elif params[1] == "delete":
if self.config_instance.esxi_info is not None:
self.config_instance.delete()
else:
self.writeresponse("ESXi info already deleted.")
else:
self.writeresponse("unknown parameters.")
else:
self.writeresponse("unknown parameters: {0}.".format(params[0]))
def yellow_font(inp_text):
return get_color_string(bcolors.YELLOW, inp_text)
def command_map(self, params):
'''[<add/list/delete/update>] [<param.1> ... <param.n>]
list/update/add mappings between VM name and PDU port
map add <datastore> <vm> <pdu> <port>
- Add an entry for VM and vPDU port
e.g.:
Add an entry.
map add datastore1 vquanta_auto1 1 2
map update <datastore> <vm> <pdu> <port>
- update an entry for VM and vPDU port
e.g.:
Update an existing datastore entry
map update datastore1 vquanta_auto1 3 1
map delete <datastore> <vm>
- Delete a datastore or a mapping for vm
e.g.:
Delete "datastore1"
map delete datastore1
Delete a mapping "vquanta_auto1 = 2" in datastore1
map delete datastore1 vquanta_auto1
map list
- List all mappings between VMs and vPDU ports
Note: when you are done to make changes, please run 'map list' to be
sure eveything is correct.
'''
if len(params) == 0:
return
if params[0] == "add" or params[0] == "update":
if len(params) != 5:
self.writeresponse(
colors.RED + "Invalid parameters." + colors.NORMAL
)
return
self.mapping_file_handle.update(params[1], params[2],
params[3], params[4])
elif params[0] == "delete":
if len(params) == 2:
self.mapping_file_handle.delete(params[1])
elif len(params) == 3:
self.mapping_file_handle.delete(params[1], params[2])
else:
self.writeresponse("Invalid parameters.")
elif params[0] == "list":
table = Texttable()
table.header(["PDU", "Port", "VM Name", "Datastore"])
table.set_cols_align(['c', 'c', 'c', 'c'])
for node_list in self.mapping_file_handle.nodes_list:
datastore = node_list.keys()[0]
for ni in node_list[datastore]:
table.add_row([
get_color_string(bcolors.GREEN, ni["control_pdu"]),
get_color_string(bcolors.GREEN, ni["control_port"]),
get_color_string(bcolors.GREEN, ni['node_name']),
get_color_string(bcolors.GREEN, datastore)
])
self.writeresponse(table.draw())
def one_all_f(sel_row, sel_col, sel_find, file):
sel_find = sel_find
keyword = 'cccZZZ'
filename = file
df = pd.read_csv(filename)
# Get columns headers
index = len(df.index)
# Get only the selected columns
columns = []
for i in sel_col:
columns.append(df.columns[i-1])
columns_index = len(columns)
# !!! Test find in columns
# print('___')
# print(df.columns.str.contains("A|C")==True)
new_list = []
old_list = []
group = []
results = []
row_group = []
row_old = ''
row_new = ''
find_flag = True
for i, data in enumerate(sel_row):
# first row
if i == 0:
# pass # ??? does it need to check i==0 ???
old_list = df.loc[data - 2, columns].tolist()
row_old = data # row number
# !!! Test searching
# print(df.loc[data - 2, columns].str.contains("aaa6|aaa4")==True)
# next rows
else:
new_list = df.loc[data - 2, columns].tolist()
row_group.append(new_list)
row_new = data # row number
# !!! Test searching
# print(df.loc[data - 2, columns].str.contains("dddd")==True)
# Group of rows. ie. #2 and #3, #3 and #4...
group = []
# for each column
for ii, old in enumerate(old_list):
# Fill empty cells with <EMPTY> to allow difflib.ndiff
if type(old) == type(0.1):
old = '<EMPTY>'
if type(new_list[ii]) == type(0.1):
new_list[ii] = '<EMPTY>'
# append first row of columns to group
if len(group) == 0:
row_info = ['Row / Col', row_old, row_new, 'Compare']
# Feature Find: Append Find if searching for a keyword
if find_flag == True:
row_info.append('Find')
# Append first column
group.append(row_info)
# Feature Compare: SAME values on temp list "col"
if old == new_list[ii]:
col = [columns[ii], old, new_list[ii], '-']
# Feature Find: color formatting and adding Yes on Find row
if col[1] == keyword:
keyword_format = f'{blackb}{greenf}{bold}{keyword}{reset}'
col[1] = keyword_format
col.append('Yes')
if col[2] == keyword:
keyword_format = f'{blackb}{greenf}{bold}{keyword}{reset}'
col[2] = keyword_format
col.append('Yes')
else:
col.append('-')
# Feature Compare: DIFFERENT values on temp list "col"
else:
col = [columns[ii], old, new_list[ii], get_color_string(bcolors.RED,"diff")]
if col[1] == keyword:
col.append('Yes')
elif col[2] == keyword:
col.append('Yes')
else:
col.append('-')
# 1st row formatting: apply color for each different character
abc = ''
a = old
b = new_list[ii]
if keyword == a:
diff_char = difflib.ndiff(b, a)
abc = diff_color_keyword(diff_char)
else:
diff_char = difflib.ndiff(b, a)
abc = diff_color(diff_char)
# for iii, s in enumerate(difflib.ndiff(b, a)):
# # APPLY different colors
# abc = ''
#
# if a == keyword:
# abc = diff_color_keyword(s, abc)
# # print(abc)
# # if s[0]==' ':
# # abc = abc + s[-1]
# # elif s[0]=='-':
# # br_color = f'{redb}{greenf}{bold}{s[-1]}{reset}'
# #
# # elif s[0]=='+':
# # br_color = f'{redb}{greenf}{bold}{s[-1]}{reset}'
# # abc = abc + br_color
#
# else:
# abc = diff_color(s, abc)
# # print(abc)
# # if s[0]==' ':
# # abc = abc + s[-1]
# # elif s[0]=='-':
# # br_color = f'{redb}{whitef}{bold}{s[-1]}{reset}'
# #
# # elif s[0]=='+':
# # br_color = f'{redb}{whitef}{bold}{s[-1]}{reset}'
# # abc = abc + br_color
# Assign wrong characters colored in red
col[1] = abc
# 2nd row formatting: apply color for each different character
abc = ''
a = old
b = new_list[ii]
if keyword == b:
diff_char = difflib.ndiff(a, b)
abc = diff_color_keyword(diff_char)
else:
diff_char = difflib.ndiff(a, b)
abc = diff_color(diff_char)
# abc = ''
# for iii, s in enumerate(difflib.ndiff(a, b)):
# if s[0]==' ':
# abc = abc + s[-1]
# elif s[0]=='-':
# br_color = f'{redb}{whitef}{bold}{s[-1]}{reset}'
# elif s[0]=='+':
# br_color = f'{redb}{whitef}{bold}{s[-1]}{reset}'
# abc = abc + br_color
# Assign wrong characters colored in red
col[2] = abc
# Check if find keyword
# if col[1] == keyword:
# k = ' '
# keyword_format = f'{greenb}{greenf}{bold}{k}{reset}'
# col[1] = keyword_format + col[1] + keyword_format
# if col[2] == keyword:
# k = 'X'
# keyword_format = f'{greenb}{greenf}{bold}{k}{reset}'
# col[2] = keyword_format + col[2] + keyword_format
# col[2] = keyword_format
# print('+++')
t1 = f'{reset}{col[2]}{reset}'
print(t1)
# !!! Test find in columns
# for col_index, col_item in enumerate(col):
# if 'aaa4' == col_item:
# col[col_index] = get_color_string(bcolors.GREEN, col_item)
# print(f'col {col}')
group.append(col)
# add group to results and reset the lists
if ii == (columns_index - 1):
results.append(group)
# clean lists
new = []
group = []
# DISABLE this reassignment to compare One row VS Rest rows
# Re-assign new list and index to old list and index
# old_list = new_list # List with row values
# row_old = row_new # Variable with row number value
print(f'------------ one vs all ------------------')
for group in results:
tab = tt.Texttable()
tab.set_deco(tab.HEADER)
for row in zip(*group):
tab.add_row(row)
s = tab.draw()
print(s, '\n')
