def test_custom_no_score():
assert ranks(Ranking([100, 50, 50, -1, -1], no_score=-1)) == \
[0, 1, 1, None, None]
assert ranks(Ranking([-1], no_score=-1)) == [None]
assert ranks(Ranking([-1, -1], no_score=-1)) == [None, None]
assert ranks(Ranking([3, 1, 1, -1], no_score=-1)) == [0, 1, 1, None]
assert ranks(Ranking([1, 1, 3, -1], reverse=True, no_score=-1)) == \
[0, 0, 2, None]
def leader(request):
"""Renders the leaderboard for all users"""
currentuser = request.user
pointlist = User.objects.filter(userpicks__game__season = currentseason)\
.annotate(points=Sum('userpicks__pick__win'))\
.order_by('-points', 'first_name')
for person in pointlist:
if person.points == None:
person.points = 0
def getPoints(self):
return self.points
def breakTie(self):
return (abs(
self.userpicks_set.get(game__game__contains=champgame).tiebreak -
true_score), self)
def getBreakTie(self):
return breakTie(self)[0]
true_score = Game.objects.get(game__contains=champgame).totalscore
if true_score is None:
ranks = Ranking(pointlist, start=1, key=getPoints)
ranklist = list(ranks)
winner = False
else:
ranks = Ranking(pointlist, start=1, key=getPoints)
ranklist = list(ranks)
firstplacelist = [x for (rank, x) in ranklist if rank == 1]
firstplaceranks = [breakTie(x) for x in firstplacelist]
firstplaceranks.sort()
firstplace = firstplaceranks[0]
pointlist2 = User.objects.filter(userpicks__game__season = currentseason)\
.exclude(id = firstplace[1].id)\
.annotate(points=Sum('userpicks__pick__win'))\
.order_by('-points', 'first_name')
for person in pointlist2:
if person.points == None:
person.points = 0
therest = Ranking(pointlist2, start=2, key=getPoints)
ranklist = list(therest)
ranklist.insert(0, (1, firstplace[1]))
winner = firstplace[1].first_name
context = {
'pointlist': ranklist,
'currentuser': currentuser,
'winner': winner
}
return render(request, 'picks/leaderboard.html', context)
def print_all_category_scores(weekly_score_dict):
team_category_map = {}
for category, category_list in weekly_score_dict.items():
category_name = category_dict[category]
category_string = f""
for index, category_tuple in Ranking(category_list,
strategy=FRACTIONAL,
key=lambda x: x[1]):
team_rank = index + 1
team_id = category_tuple[0]
team_name = team_dict[team_id]
team_category_value = category_tuple[1]
if team_name in team_category_map:
team_category_map[team_name].update({
category_name: {
"rank": team_rank,
"category_value": team_category_value
}
})
else:
team_category_map[team_name] = {
category_name: {
"rank": team_rank,
"category_value": team_category_value
}
}
category_string += f' ({team_rank}) {team_name} {team_category_value} |'
print(category_string)
return team_category_map
def get_csv(df, csv_path, risk_factor, questions, top_k = 1, device = -1, dict_path = 'Data/ranking_dict'):
dataset = df #pd.read_csv(df_path, sep=';')
ranking = Ranking('texts', path= dict_path)
qa_model = pipeline('question-answering', device=device, model='bert-large-uncased-whole-word-masking-finetuned-squad')
print('All loaded')
all_query = ' '.join(questions)
documents = get_documents(dataset, ranking, all_query, top_k = top_k)
print('Length documents: {}'.format(len(documents)))
results = pd.DataFrame(columns=['date', 'title', 'authors', 'design', 'level_of_evidence'] + questions)
print('Starting docs for {}: \n'.format(risk_factor))
for doc in documents:
row = dataset.loc[dataset.text == doc]
new_line = get_information(row)
#new_line = {'paper_id': paper_id}
for query in questions:
answer, paragraph = get_answer_from_doc(query, doc, qa_model)
new_line[query] = str(paragraph.replace(answer, f"<mark>{answer}</mark>"))
print(answer)
results = results.append(new_line, ignore_index=True)
results.to_csv(csv_path, sep=';', index=False)
def calculate_final_rankings(round_dicts, total_players=24):
number_matches = 0
previous_number_matches = 0
for index, round in enumerate(round_dicts):
number_matches = number_matches + len(round['division_final_matches'])
if round['completed'] is not True:
continue
unranked_match_players = []
matches_in_current_round = len(round['division_final_matches'])
for match in round['division_final_matches']:
for match_player in match['final_match_player_results']:
if match_player['winner'] is not True or index == len(
round_dicts) - 1:
unranked_match_players.append(match_player)
sorted_player_list = sorted(unranked_match_players,
key=lambda e: e['papa_points_sum'],
reverse=True)
ranked_player_list = list(
Ranking(sorted_player_list, key=lambda pp: pp['papa_points_sum']))
ranked_player_dict = {
ranked_player[1]['final_player_id']: ranked_player
for ranked_player in ranked_player_list
}
base_rank = total_players - (number_matches * 4) / 2
if index == len(round_dicts) - 1:
base_rank = 0
for ranked_final_player_id, ranked_final_player in ranked_player_dict.iteritems(
):
if ranked_final_player[1]['winner'] is not True or index == len(
round_dicts) - 1:
ranked_final_player[1][
'final_rank'] = base_rank + ranked_final_player[0] + 1
def remove_missing_final_player(final_player_list, app):
pruned_final_players = []
final_player_list = [
final_player for final_player in final_player_list
if final_player['type'] == 'result'
]
for final_player in final_player_list:
if 'removed' in final_player and final_player['removed'] is not True:
final_player['removed '] = False
final_player['reranked_seed'] = final_player['initial_seed']
pruned_final_players.append(final_player)
sorted_final_players = sorted(pruned_final_players,
key=lambda e: e['reranked_seed'])
reranked_pruned_final_players_list = list(
Ranking(sorted_final_players,
key=lambda pp: pp['reranked_seed'],
reverse=True))
# NOTE : reranked ranks start at 0, not 1
reranked_pruned_final_players_hash = {
final_player[1]["player_id"]: final_player[0]
for final_player in reranked_pruned_final_players_list
}
for index, final_player in enumerate(final_player_list):
#if 'removed' in final_player and final_player['removed']:
# final_player['initial_seed']=None
if 'removed' in final_player and final_player['removed'] is False:
final_player['reranked_seed'] = reranked_pruned_final_players_hash[
final_player['player_id']]
return final_player_list
def get_ranking(self):
"""
returns a ranking list, containing the ranks of the included
target translations
@return: the ranking list
@rtype: Ranking
"""
return Ranking([s.get_rank() for s in self.tgt])
def getRankingForFile(self, filename) -> Ranking:
repetition = defaultdict(lambda: 0)
for baseWord in self._generate(filename):
repetition[baseWord] += 1
ranking = sorted(repetition.items(), key=itemgetter(1), reverse=True)
return Ranking(ranking)
def human_rank(self):
from data_apis import top_human_squads
ths = top_human_squads(self.game)
squad_score = [
x['human_points'] for x in ths if x['squad_id'] == self.id
][0]
scores = [x['human_points'] for x in ths]
return (Ranking(scores, start=1).rank(squad_score), len(ths))
def zombie_rank(self):
from data_apis import top_zombie_squads
tzs = top_zombie_squads(self.game)
squad_score = [
x['zombie_points'] for x in tzs if x['squad_id'] == self.id
][0]
scores = [x['zombie_points'] for x in tzs]
return (Ranking(scores, start=1).rank(squad_score), len(tzs))
def human_rank(self):
from data_apis import top_humans
th = top_humans(self.game)
player_score = [
x['human_points'] for x in th if x['player_id'] == self.id
][0]
scores = [x['human_points'] for x in th]
return (Ranking(scores, start=1).rank(player_score), len(th))
def testAddUsersFromDB(self):
self.R.reset()
self.R.c.executemany(queries.INSERT_KNOWN_USERS, USERS)
R = Ranking(1, conn=self.R.conn)
self.assertTrue(all([user[0] in R.known_users for user in USERS]),
"All of the users were not added from DB")
def test_capsuled_scores():
class User(object):
def __init__(self, score):
self.score = score
def __lt__(self, other):
raise NotImplemented
def __gt__(self, other):
raise NotImplemented
users = [User(100), User(80), User(80), User(79)]
with raises(TypeError):
list(Ranking(users))
key = lambda user: user.score
ranking = Ranking(users, key=key)
assert ranks(ranking) == [0, 1, 1, 3]
assert isinstance(next(iter(ranking))[1], User)
def guarda_puntajes(self):
partida = Ranking(self.master.master.puntaje.get(),
self.master.master.nombre.get(),
self.master.master.dificultad.get(),
self.tiempo_juego_total, constantes.RANKING)
if partida.es_puntaje_alto():
t = Timer(1.1, lambda: [self.aviso_puntaje_alto()])
t.start()
partida.guarda_partida_csv()
partida.ordena_puntaje_cvs()
def rank(x, ties_method="average"):
ox = np.argsort(-x)
sx = np.argsort(ox)
if ties_method == "average":
strategy = ranking.FRACTIONAL
else:
strategy = ranking.COMPETITION
r = Ranking(x[ox], strategy=strategy, start=1)
rnks = list(r.ranks())
return np.array(rnks)[sx]
def testAddDualsFromDB(self):
self.R.c.executemany(queries.INSERT_DUALS, DUALS)
self.R.c.executemany(queries.INSERT_RATINGS, RATINGS)
R = Ranking(1, self.R.conn)
submitters = [user[0] for user in USERS]
self.assertTrue(
all(dual.submitter[0] in submitters for dual in R.duals),
"All of the duals were not added from the DB")
def sort_user_results_with_rankings(results: List[UserEventResults],
event_format: EventFormat) -> List[Tuple[int, str, UserEventResults]]:
""" Sorts a list of UserEventResults based on the event format (for tie-breaking), and then applies rankings
(identical results receive identical rankings). Returns a list of tuples of the form (ranking, visible_ranking,
userEventResult), where ranking is the raw numerical rank and visible_ranking is the same as ranking except
duplicate ranks show as an empty string. """
# Best-of-N results are only ranked by singles
if event_format in [EventFormat.Bo1, EventFormat.Bo3]:
results.sort(key=__sort_user_event_results_by_result)
# Average/mean results are sorted by single first, to ensure any ties by overall result (average/mean) are broken
# by the singles.
else:
results.sort(key=__sort_user_event_results_by_single)
results.sort(key=__sort_user_event_results_by_result)
# Build a list of tuples (average/mean, single), to be fed into the ranking mechanism.
# If the time value cannot be interpreted as an int, it's a "DNF" or None, so just assign it some humongous value
# which would sorted at the end.
times_values = list()
for result in results:
try:
average = int(result.result)
except (ValueError, TypeError):
average = 9999999999999
try:
single = int(result.single)
except (ValueError, TypeError):
single = 9999999999999
times_values.append((average, single))
# Rank the list of times tuples. Legitimately tied results will have the same rank, so we also send back a
# "visible rank" which facilitates showing the results nicely. Ranks with ties will look something like this:
#
# Place Result
# ----- ------
# 1 10.2
# 2 15
# 15
# 4 17.84
ranks_seen = set()
ranked_results = list()
for i, r in enumerate(Ranking(times_values, start=1, reverse=True)):
rank = r[0]
if rank not in ranks_seen:
ranks_seen.add(rank)
visible_rank = str(rank)
else:
visible_rank = ''
ranked_results.append((rank, visible_rank, results[i]))
return ranked_results
def testAddSinglesFromDB(self):
self.R.reset()
self.R.c.executemany(queries.INSERT_SINGLES, SINGLES)
self.R.c.executemany(queries.INSERT_RATINGS, RATINGS)
R = Ranking(1, self.R.conn)
submitters = [user[0] for user in USERS]
self.assertTrue(
all(match.submitter[0] in submitters for match in R.singles),
"All of the matches were not added from the DB")
def zombie_rank(self):
from data_apis import top_zombies
tz = top_zombies(self.game)
try:
player_score = [
x['zombie_points'] for x in tz if x['player_id'] == self.id
][0]
except:
return None
scores = [x['zombie_points'] for x in tz]
return (Ranking(scores, start=1).rank(player_score), len(tz))
def update():
container = Artikel.query.all()
preproses = PreProses(container)
stopword = preproses.stopword()
stemming = preproses.stemming(stopword)
normalisasi = preproses.normalisasi(stemming)
koleksi = preproses.koleksi(normalisasi)
rank_store = Ranking(normalisasi, koleksi)
bobot_doc = rank_store.bobotDokumen()
bobot_kata = rank_store.bobotKata(bobot_doc)
bobot_kata_doc = rank_store.bobotKataDokumen(bobot_kata, bobot_doc)
Koleksi.query.delete()
Indexing.query.delete()
BobotDoc.query.delete()
BobotKata.query.delete()
BobotKataDoc.query.delete()
key_id = []
for x in container:
key_id.append(str(x.id))
for i, dokumen in enumerate(normalisasi):
for kata in dokumen:
key = key_id[i]
indexing_db = Indexing(key, kata)
db.session.add(indexing_db)
db.session.commit()
for kata in koleksi:
koleksi_db = Koleksi(kata)
db.session.add(koleksi_db)
db.session.commit()
for i, dokumen in enumerate(bobot_doc):
for kata in dokumen:
index = str(i + 1)
bobot_doc_db = BobotDoc(index, kata)
db.session.add(bobot_doc_db)
db.session.commit()
for kata in bobot_kata:
bobot_kata_db = BobotKata(kata)
db.session.add(bobot_kata_db)
db.session.commit()
for i, dokumen in enumerate(bobot_kata_doc):
for kata in dokumen:
index = str(i + 1)
bobot_kata_doc_db = BobotKataDoc(index, kata)
db.session.add(bobot_kata_doc_db)
db.session.commit()
return redirect(url_for('admin', success='Articles successfully updated'))
async def load_all(self):
self.messages = load_messages()
self.player_manager = PlayerManager()
await self.player_manager.load_data()
await self.update_mentions()
ranking_config = load_ranking_config("base")
self.ranking = Ranking(self.player_manager,
**ranking_config)
await self.ranking.fetch_data(self.matchboard)
def convertToRanks(freqDistBigrams):
#print("In RANKING")
#print(freqDistBigrams)
freqList = [x[1] for x in freqDistBigrams]
#print(freqList)
rankList = list(Ranking(freqList, start=1))
#print(rankList)
freDist_New = [
tuple([x[0], y[0]]) for x, y in zip(freqDistBigrams, rankList)
]
#print(freDist_New)
return freDist_New
def rank(self):
competitors = self.competitors.filter(
is_private=False,
status__gt=0,
).distinct().order_by('-tot_points')
points = [x.tot_points for x in competitors]
ranked = Ranking(points, strategy=ORDINAL, start=1)
for competitor in competitors:
competitor.tot_rank = ranked.rank(competitor.tot_points)
competitor.save()
competitors = self.competitors.filter(
is_private=False,
status__gt=0,
).distinct().order_by('-mus_points')
points = [x.mus_points for x in competitors]
ranked = Ranking(points, start=1)
for competitor in competitors:
competitor.mus_rank = ranked.rank(competitor.mus_points)
competitor.save()
competitors = self.competitors.filter(
is_private=False,
status__gt=0,
).distinct().order_by('-per_points')
points = [x.per_points for x in competitors]
ranked = Ranking(points, start=1)
for competitor in competitors:
competitor.per_rank = ranked.rank(competitor.per_points)
competitor.save()
competitors = self.competitors.filter(
is_private=False,
status__gt=0,
).distinct().order_by('-sng_points')
points = [x.sng_points for x in competitors]
ranked = Ranking(points, start=1)
for competitor in competitors:
competitor.sng_rank = ranked.rank(competitor.sng_points)
competitor.save()
return
def __init__(self, seed_file, data_dir, similarity_method):
if not os.path.exists(data_dir):
os.makedirs(data_dir)
self.ranked_urls_file = data_dir + "/ranked_urls.csv"
self.seed_urls = self._read_urls_from_file(seed_file)
print "Number of seed urls: ", len(self.seed_urls)
self.discovered_urls = set()
for url in self.seed_urls:
self.discovered_urls.add(url)
self.searcher = Search_APIs(data_dir)
self.ranker = Ranking(data_dir, self.seed_urls, similarity_method)
self.seed_threshold = 0.1 # minimum score for an url to be selected as a seed
self.search_threshold = 0.05 # minimum score for an url to be selected for search
def __init__(self, win, connection=None):
pygame.font.init()
self.connection = connection
self.win = win # okno do wyswietlania
# inicjalizacja parametrow
self.ranking = Ranking(50, 125)
self.tablica = Tablica(305, 125)
self.pasek_gorny = PasekGorny(50, 10, 990, 100)
self.pasek_gorny.zmiana_rundy(1)
self.gracze = []
self.pomin_button = PrzyciskTekstowy(810, 555, 225, 50, (255, 255, 0), "Pomin")
self.pasek_dolny = PasekDolny(305, 880, self)
self.chat = Chat(810, 125)
self.kolor_rysowania = (0, 0, 0)
self.rysujacy = False
async def exp_ranking(cmd, mu, sigma, beta, tau):
t = time.time()
async with cmd.typing():
player_manager = PlayerManager()
await player_manager.load_data()
await kamlbot.update_mentions(player_manager=player_manager)
kamlbot.experimental_ranking = Ranking(player_manager,
mu=eval(mu),
sigma=eval(sigma),
beta=eval(beta),
tau=eval(tau))
await kamlbot.experimental_ranking.fetch_data(kamlbot.matchboard)
dt = time.time() - t
await cmd.channel.send(f"Experimental ranking initialized in {dt:.2f} s.")
def list(self, request):
try:
date_from = request.GET.get('date_from', '2.1.1410')
date_from = datetime.datetime.strptime(date_from, '%d.%m.%Y')
except ValueError:
date_from = datetime.date(1410, 8, 15)
date_from -= datetime.timedelta(days=1)
try:
date_to = request.GET.get('date_to', '31.12.9999')
date_to = datetime.datetime.strptime(date_to, '%d.%m.%Y')
except ValueError:
date_to = datetime.date(9999, 12, 31)
# cmnt = Movie.objects.filter(
# Q(comment__date__range=(date_from, date_to)) |
# Q(comment__date__isnull=True)).values("id").annotate(
# total_comments=Count("comment")).order_by('-total_comments')
# SQL STMT that can do all above and adds 0 for movies with no comments
# but much easier
sql_qry = \
'SELECT "movies_movie"."id" AS "movie_id", ' \
'SUM(CASE WHEN "movies_comment"."date" ' \
'BETWEEN datetime("%s") AND datetime("%s") ' \
'THEN 1 ELSE 0 end) as "total_comments" ' \
'FROM "movies_movie" LEFT OUTER JOIN "movies_comment" ' \
'ON ("movies_movie"."id" = "movies_comment"."movie_id_id") ' \
'GROUP BY "movies_movie"."id" ' \
'ORDER BY "total_comments" DESC' % (date_from, date_to)
with connection.cursor() as c:
c.execute(sql_qry)
"Return all rows from a cursor as a dict"
columns = [col[0] for col in c.description]
cmnt = [dict(zip(columns, row)) for row in c.fetchall()]
# add rank
total_comments = [c['total_comments'] for c in cmnt]
ranked_comments = list(Ranking(total_comments, strategy=DENSE))
for i in range(len(cmnt)):
cmnt[i]['rank'] = ranked_comments[i][0] + 1
return Response(cmnt)
def testMatchesPerUser(self):
self.R.reset()
self.R.c.executemany(queries.INSERT_KNOWN_USERS, USERS)
self.R.c.executemany(queries.INSERT_RATINGS, RATINGS)
# Use a fresh Ranking to load the information from DB
R = Ranking(1, conn=self.R.conn)
for dual in DUALS:
R.add_dual_match((dual[0], dual[4]), (dual[1], dual[5]),
(dual[2], dual[6]), (dual[3], dual[7]), dual[8],
dual[9], dual[10])
try:
R.matches_per_user()
except Exception:
self.fail(
"Calculating the number of matches per user should not throw error."
)
def ranking(self, obj, scoreing_class = None, validation_class = None,
scoreing_args = None, validation_args = None, reverse = False):
"""
Get a ranking for a Rankable object
@param obj: ranked object (Category, Course, ...)
@param scoreing_class: scoreing strategy used, None for default strategy
@param validation_class: validation strategy used, None for default strategy
@param scoreing_args: scoreing args, None for default args
@param validation_args: validation args, None for default args
@param reverse: produce reversed ranking
"""
if type(obj) == OpenRuns:
scoreing_class = scoreing_class or ControlPunchtimeScoreing
validation_class = validation_class or ControlPunchtimeScoreing
validation_args = validation_args or scoreing_args
reverse = True
return Ranking(obj, self, scoreing_class, validation_class,
scoreing_args, validation_args, reverse)
def mainLoop():
global config
global ranking
global chatIds
config = util.readConfig()
ranking = Ranking(config)
chatIds = util.readChatIds()
tg.readRequestUrl()
callbacks = [(checkUpcomingContest, 60, 0), (tg.startPolling, 1, 0)]
while True:
for i in range(len(callbacks)):
(fun, timeIt, lastTimeStamp) = callbacks[i]
if time.time() - lastTimeStamp >= timeIt:
callbacks[i] = (fun, timeIt, time.time())
try:
fun()
except Exception as e:
traceback.print_exc()
print(traceback.format_exc())
time.sleep(0.01)
