def print_type_effectiveness(self):
'''prints the type effectiveness in a pretty table'''
o = sorted(self.typing.offensive_raw, key=lambda x: x[0])
d = sorted(self.typing.defensive_raw, key=lambda x: x[0])
n = [i[0] for i in o]
c = ['Offensive', 'Defensive']
a = [[i[1] for i in o], [i[1] for i in d]]
print(tg3.Table(n, c, a))
def unit_compare(file):
kids = kit.sdnt_convert(file)
with open(file) as file_obj:
gradebook = json.load(file_obj)
comparing = []
print('Which assignments will you compare? Type DONE to finish')
print(*gradebook['assignments'], sep = '\n')
while True:
x = input('\n>> ')
if x.lower() == 'done':
break
elif x not in gradebook['assignments'] or x in comparing:
print('Not a valid assignment')
elif x in gradebook['assignments'] and x not in comparing:
comparing.append(x)
else:
print('Those conditions are mutually exclusive! I dunno how you did this....')
ci = [gradebook['assignments'].index(a) for a in comparing]
grades = [[(k.marks[a] / gradebook['possible_marks'][a]) * 100 for k in kids] for a in ci]
means = [np.mean(a) for a in grades]
diffs = [[kit.srt(e - means[l], 0) for e in grades[l]] for l in range(len(grades))]
for group in diffs:
for num in range(len(group)):
v = group[num]
if v[0] != '-' and v != '0.0':
group[num] = '+' + v
kid_diffs = [[int(float(group[r])) for group in diffs] for r in range(len(kids))]
remarks = []
for kid in kid_diffs:
if sum([np.sign(u) for u in kid]) == -1 * len(kid):
remarks.append('Needs Help')
elif sum([i > 20 for i in kid]) == len(kid):
remarks.append('Above Average')
else:
remarks.append('')
diffs.append(remarks)
comparing.append('Remarks')
ctable = tg3.Table([k.name for k in kids], comparing, diffs)
print(ctable.table)
def assignment_analysis(file):
kids = kit.sdnt_convert(file)
with open(file) as file_obj:
gradebook = json.load(file_obj)
print('Which assignment will you analyze?')
print(*gradebook['assignments'], sep = '\n')
subject = kit.pick_one(gradebook['assignments'], '\nWe will analyze... ')
place = gradebook['assignments'].index(subject)
out_of = gradebook['possible_marks'][place]
s_marks = [k.marks[place] for k in kids]
b_marks = [k.marks[place] for k in kids if k.sex == 'Boy']
g_marks = [k.marks[place] for k in kids if k.sex == 'Girl']
a_marks = [s_marks, b_marks, g_marks]
data = []
for cat in a_marks:
percents = [(cat[l] / out_of) * 100 for l in range(len(cat))]
m = round(np.mean(cat), 2)
a = round(len([i for i in percents if i >= 90]), 2)
b = round(len([i for i in percents if i >= 80 and i < 90]), 2)
c = round(len([i for i in percents if i >= 70 and i < 80]), 2)
d = round(len([i for i in percents if i >= 60 and i < 70]), 2)
f = round(len([i for i in percents if i > 0 and i < 60]), 2)
z = round(len([i for i in percents if i == 0]), 2)
data.append([m, a, b, c, d, f, z])
axis = ['All', 'Boys', 'Girls']
ayis = ['Mean', '90 - 100', '80 - 89', '70 - 79', '60 - 69', '1 - 59', 'Zeros']
atable = tg3.Table(ayis, axis, data)
print(atable.table)
plt.hist(s_marks)
plt.title('{} Score Distribution'.format(subject))
plt.xlabel('Scores')
plt.ylabel('These Darn Kids')
plt.show()
def grade_check(file_name):
kids = kit.sdnt_convert(file_name)
names = [stdnt.name for stdnt in kids]
with open(file_name) as file_obj:
gradebook = json.load(file_obj)
print('\nGrade Check')
while True:
to_see = input('Student Name >> ')
if to_see in names:
index = names.index(to_see)
break
elif to_see.lower() == 'check':
print(*names, sep='\n')
else:
print("That's not a student")
sir_you_tried = kit.name_attempt(gradebook, to_see)
if len(sir_you_tried) > 0:
print('Maybe you mean...')
print(*sir_you_tried, sep='\n')
subject = kids[index]
work = gradebook['assignments']
cats = ['Marks', 'Class Avg', 'Position']
print(subject)
all_marks = [[k.marks[i] for k in kids] for i in range(len(work))]
class_avg = [round(np.mean(m), 2) for m in all_marks]
bars = [
kit.comp_bar(subject.marks[a], all_marks[a]) for a in range(len(work))
]
final = [subject.marks, class_avg, bars]
mtable = tg3.Table(work, cats, final)
print(mtable.table)
input('Done?')
os.system('cls')
def SBA(file_name):
kids = kit.sdnt_convert(file_name)
for x in ['Boy', 'Girl']:
names = [stdnt.name for stdnt in kids if stdnt.sex == x]
final_grades = [
round(stdnt.grade * 100, 1) for stdnt in kids if stdnt.sex == x
]
term_grade = [round(i / 2, 1) for i in final_grades]
test_grade = [round(.4 * i, 1) for i in term_grade]
classwork = [round(.2 * i, 1) for i in term_grade]
ranks = [stdnt.ranked for stdnt in kids if stdnt.sex == x]
columns = [
'Test 1', 'Project Work', 'Test 2', 'Group Work', 'Term Total',
'Final Exam', 'Final Grade', 'Ranks'
]
sba_data = [
test_grade, classwork, classwork, classwork, term_grade,
term_grade, final_grades, ranks
]
print('\n--- {}s ---'.format(x))
sba = tg3.Table(names, columns, sba_data)
print(sba.table)
# Analysis ################################################################
move_data = []
summary = []
damage_classes = ['All', 'Physical', 'Special']
for c in damage_classes:
x = move_means(c)[0]
y = [str(i) for i in x]
move_data.append(y)
a = move_means(c)[1]
b = str(round(a, 2))
summary.append(b)
###########################################################################
all_rows = [i.upper() for i in kit.type_list]
damage_table = tg.Table(all_rows, damage_classes, move_data, summary)
print(damage_table)
#--\### Mean Expected Damage is distributed uniformly accross type so its not a
#---\## significant factor in type selection ASSUMING every type has an equal
#----\# offensive presence
#----|###############################################\
#----\#---------------------------------------------# \
# #| | All | Physical | Special |# \
# #|-----------|--------|-----------|----------|# \
# #| NORMAL | 63.93 | 65.19 | 59.38 |#\ \
# #| FIGHTING | 65.8 | 66.53 | 60.0 |#_\ \
# #| FLYING | 75.33 | 76.82 | 71.25 |#__\ \
# #| POISON | 65.33 | 64.17 | 66.11 |#___\ \
# #| GROUND | 65.0 | 68.0 | 57.5 |#____\ \
# #| ROCK | 80.82 | 83.23 | 70.0 |#_____\ \
# #| BUG | 66.82 | 70.37 | 59.0 |#______\ \
round(list(class_pref.values())[i] / capd_class_sizes[i], 2)
for i in range(6)
]
###############################################################################
## Building tables ##
###############################################################################
np_data = list(npc.values())
detlen = max([len(l) for l in np_data])
for l in np_data:
while len(l) < detlen:
l.append('')
np_rnames = ['' for i in range(detlen)]
np_cnames = list(npc.keys())
np_table = tg.Table(np_rnames, np_cnames, np_data)
#print(np_table) # Print only in terminal, not console
rnames = list(registers.keys())
cnames = ['No Pics', '# Pics', 'Mean Pics']
info = [list(counted.values()), list(class_pref.values()), mean_pics]
table = tg.Table(rnames, cnames, info)
print(table)
###############################################################################
## Checking Gender Split ##
###############################################################################
girls = []
boys = []
for r in registers.values():
def grade_analysis(file, form):
kids = kit.sdnt_convert(file)
with open(file) as file_obj:
gradebook = json.load(file_obj)
all_grades = [stdnt.grade*100 for stdnt in kids]
boys_grades = [stdnt.grade*100 for stdnt in kids if stdnt.sex == 'Boy']
girls_grades = [stdnt.grade*100 for stdnt in kids if stdnt.sex == 'Girl']
grade_groups = [all_grades, boys_grades, girls_grades]
class_data = [[], [], []]
subj_titles = ['Count', 'Mean', 'Median', 'St Dev', 'Range', 'Pass Rate']
group_titles = ['All', 'Boys', 'Girls']
limit = kit.int_check("Lower Pass Boundry (1-99)>> ")
for i in range(3):
class_data[i].append(len(grade_groups[i]))
class_data[i].append(kit.srt(np.mean(grade_groups[i])) + '%')
class_data[i].append(str(np.median(grade_groups[i])) + '%')
class_data[i].append(kit.srt(np.std(grade_groups[i])) + '%')
class_data[i].append(kit.srt(max(grade_groups[i]) - min(grade_groups[i])) + '%')
class_data[i].append((kit.srt(len([grade for grade in grade_groups[i] if grade > limit])/len(grade_groups[i])* 100)) + "%")
atable = tg3.Table(subj_titles, group_titles, class_data)
print(atable.table)
all_assigned = gradebook['assignments']
grades = {}
for assigned in all_assigned:
dex = all_assigned.index(assigned)
top_score = gradebook['possible_marks'][dex]
grades[assigned] = [stdnt.marks[dex]/top_score * 100 for stdnt in kids]
analysis = [[], [], [], []]
for key in grades:
analysis[0].append(kit.srt(max(grades[key])) + '%')
analysis[2].append(kit.srt(min(grades[key])) + '%')
analysis[1].append(kit.srt(np.mean(grades[key])) + '%')
p = [g for g in grades[key] if g >= limit]
pr = len(p)/len(grades[key])
analysis[3].append(kit.srt(pr * 100) + "%")
cats = ['Max Grade', 'Avg Grade', 'Min Grade', 'Pass Rate']
gtable = tg3.Table(all_assigned, cats, analysis)
print(gtable.table)
print('The Top Five: ')
for i in range(1, 6):
for stdnt in kids:
if stdnt.ranked == i:
print(stdnt)
plt.figure(figsize = (8, 8))
my_plot = sns.distplot(all_grades)
line = my_plot.get_lines()[-1]
x, y = line.get_data()
mask = x > limit
x, y = x[mask], y[mask]
my_plot.fill_between(x, y1 = y, alpha = .5, facecolor = 'red')
plt.title('Score Dictribution of {}'.format(form))
plt.xlim(0, 100)
plt.xlabel('Grades')
plt.ylabel('Frequency')
plt.show()
sns.violinplot(data = grade_groups[1:])
plt.title('Grade Distributions')
plt.xlabel(' '.join(group_titles[1:]))
plt.ylabel('Grades')
plt.show()
if 'Final Exam' in all_assigned:
loc = all_assigned.index('Final Exam')
top = gradebook['possible_marks'][loc]
plt.figure(figsize = (8, 8))
exam_marks = [stdnt.marks[loc] for stdnt in kids]
plt.hist(exam_marks)
plt.title('Final Exam Score Distribution')
plt.ylabel('Count')
plt.xlabel('Marks')
plt.vlines(x = top, ymin = 0, ymax = 10)
plt.show()
def team_calculator(team):
"""Take 6 pokemon and see how they work together. This measues team synergy
not team effectiveness or strategy. It also gives a numeric approach to
find the weaker links in a team. It will never be able to accurately
recognise strategy."""
monsters = team[0]
builds = team[1]
## Typing Synchronicity ###################################################
###########################################################################
covers = [strat.typing.see('cover') for strat in builds]
resists = [strat.typing.see('resist') for strat in builds]
walled = [strat.typing.see('walled') for strat in builds]
weak = [strat.typing.see('weak') for strat in builds]
all_cover = [t for l in covers for t in l]
all_resists = [t for l in resists for t in l]
all_weak = [t for l in weak for t in l]
team_holes = [q for q in kit.type_list if q not in all_cover]
no_wall = [q for q in kit.type_list if q not in all_resists]
no_weak = [q for q in kit.type_list if q not in all_weak]
cover_counted = Counter(all_cover)
resists_counted = Counter(all_resists)
weak_counted = Counter(all_weak)
for q in no_weak:
weak_counted[q] = 0
for q in team_holes:
cover_counted[q] = 0
for q in no_wall:
resists_counted[q] = 0
scores = []
for i in range(6):
good = len(covers[i]) + len(resists[i])
bad = len(weak[i])
for p in covers[i]:
good += 1 / cover_counted[p]
for p in resists[i]:
good += 1 / resists_counted[p]
for p in weak[i]:
bad += 1 / weak_counted[p]
scores.append(round(good / max(1, bad), 2))
## Role Synchronicity #####################################################
###########################################################################
nat_roles = [strat.role for strat in builds]
det_roles_start = [pkmn.get_role_array() for pkmn in monsters]
for i in range(6):
for v in det_roles_start[i]:
v.insert(2, i)
det_role_scores = [t for l in det_roles_start for t in l]
roles_sorted = sorted(det_role_scores, key=lambda x: x[1], reverse=True)
roles_copy = roles_sorted.copy()
det_roles = ['???' for i in range(6)]
used = []
while '???' in det_roles:
up = roles_sorted[0]
det_roles[up[2]] = up[0]
used.append(up[2])
used.append(up[0])
for i in roles_copy:
try:
if i[2] in used or i[0] in used:
roles_sorted.remove(i)
except ValueError:
pass
## Stats Synchronicity ####################################################
###########################################################################
stats = [strat.stats_array for strat in builds]
means = [np.mean([s[i] for s in stats]) for i in range(6)]
bests = []
for s in range(6):
detail = [[kit.base_stats[i], stats[s][i]] for i in range(6)]
sd = sorted(detail, key=lambda x: x[1], reverse=True)
bests.append(sd[:2])
stat_scores = []
for s in range(6):
top_score = bests[s][0][1]
top_name = bests[s][0][0]
runner_up = bests[s][1][1]
silver_name = bests[s][1][0]
m1 = kit.base_stats.index(top_name)
m2 = kit.base_stats.index(silver_name)
score1 = (top_score / means[m1])
score2 = (runner_up / means[m2])
stat_scores.append(round((score1 + score2 - 2) * 10, 2))
cmod = len(set(all_cover)) * len(all_cover)
rmod = len(set(all_resists)) * len(all_resists)
wmod = len(set(all_weak)) * len(all_weak)
typing_modifier = (cmod + rmod) / wmod
holes_modifier = 0
if len(team_holes) > 0:
for i in team_holes:
if i in all_weak:
holes_modifier -= .1
else:
holes_modifier += .5
weak_modifier = 0
if len(no_wall) > 0:
for i in no_wall:
if i in all_weak:
weak_modifier -= .1
else:
weak_modifier += .5
skill_modifiers = []
stat_cols = [
'base_hp', 'base_atk', 'base_def', 'base_spatk', 'base_spdef',
'base_spd'
]
for monster in stats:
for i in range(6):
stat_pull = kit.SQL_pull(stat_cols[i], 'pokemon', 'evolved = 1')
if i == 0:
stat = [(2 * (pkmn[0] + 31)) + 110 for pkmn in stat_pull]
else:
stat = [(2 * (pkmn[0] + 31)) + 5 for pkmn in stat_pull]
stat_mean = np.mean(stat)
stat_sig = np.std(stat)
z = (monster[i] - stat_mean) / stat_sig
skill_modifiers.append(z)
skill_modifier = round(sum(skill_modifiers) / 6, 2)
range_modifier = 0
role_arrays = [pkmn.get_role_array() for pkmn in monsters]
dead_weight = []
for i in range(6):
subject = role_arrays[i]
nscore = [s[1] for s in subject if s[0] == nat_roles[i]][0]
dscore = [s[1] for s in subject if s[0] == det_roles[i]][0]
dwl = nscore - dscore
loss = (dwl / 180) * .3
range_modifier += .3 - loss
dead_weight.append(dwl)
stat_collections = [[s[i] for s in stats] for i in range(6)]
stat_averages = [np.mean(c) for c in stat_collections]
stat_var = [np.var(c) for c in stat_collections]
final_sigma = np.sqrt(sum(stat_var))
max_z = (max(stat_averages) - np.mean(stat_averages)) / final_sigma
min_z = (min(stat_averages) - np.mean(stat_averages)) / final_sigma
balance_modifier = round((max_z + min_z) * 2.5, 2)
team_score = balance_modifier + range_modifier + typing_modifier + weak_modifier + holes_modifier + skill_modifier
## Data Return ############################################################
###########################################################################
print('\n --STATS BREAKDOWN--')
NAMES = [m.name.upper() for m in monsters]
bs_arrays = [pkmn.base_array for pkmn in monsters]
stat_totals = [pkmn.bst for pkmn in monsters]
stats_table = tg.Table(kit.base_stats, NAMES, bs_arrays, stat_totals)
print(stats_table)
print('\n --STATS ANALYSIS--')
scnames = ['Strat Role', 'Det Role', 'Role Loss', 'St. Dev.', 'Score']
ind_sigmas = [pkmn.stat_std for pkmn in monsters]
sdata = [nat_roles, det_roles, dead_weight, ind_sigmas, stat_scores]
sanal_table = tg.Table(NAMES, scnames, sdata)
print(sanal_table)
print('\n --MOVESET BREAKDOWN--')
movesets = [[m.name for m in p.algo_moveset] for p in builds]
move_table = tg.Table(['SLOT {}'.format(i) for i in range(1, 5)], NAMES,
movesets)
print(move_table)
print('\n --TYPING BREAKDOWN--')
cover_tuples = sorted(list(cover_counted.items()), key=lambda x: x[0])
wall_tuples = sorted(list(resists_counted.items()), key=lambda x: x[0])
weak_tuples = sorted(list(weak_counted.items()), key=lambda x: x[0])
bcnames = ["Covers", "Resists", "Weak"]
bdata = [[c[1] for c in cover_tuples], [w[1] for w in wall_tuples],
[w[1] for w in weak_tuples]]
breakdown_table = tg.Table([t[0].upper() for t in cover_tuples], bcnames,
bdata)
print(breakdown_table)
print('\n --TYPING ANALYSIS--')
covers_summary = [len(x) for x in covers]
walled_summary = [len(x) for x in walled]
resists_summary = [len(x) for x in resists]
weak_summary = [len(x) for x in weak]
tcnames = ["Covers", "Walled", "Resists", "Weak", "Score"]
tdata = [
covers_summary, walled_summary, resists_summary, weak_summary, scores
]
tanal_table = tg.Table(NAMES, tcnames, tdata)
print(tanal_table)
print("\nSpecialization: + {}".format(skill_modifier))
print("Role Fulfilment: + {}".format(range_modifier))
print("Stat Balance: + {}".format(balance_modifier))
print("Type Economy: + {}".format(typing_modifier))
print("Resistence Capability: + {}".format(weak_modifier))
print("Coverage Capability: + {}".format(holes_modifier))
print("\nTEAM SCORE: {}".format(team_score))
print("\n" + "~~" * 50)