async def get_fastest_times_league_infotext(league_tag: str,
limit: int) -> str:
fastest_times = await leaguedb.get_fastest_wins_raw(league_tag, limit)
max_namelen = 0
namelen_cap = 20
for row in fastest_times:
if row[1] is None:
continue
max_namelen = max(max_namelen, len(row[1]), namelen_cap)
dated_format_str = ' {winner:>' + str(max_namelen) + '.' + str(max_namelen) + \
'} -- {time:<9} (vs {loser}, {date:%b %d})\n'
undated_format_str = ' {winner:>' + str(max_namelen) + '.' + str(max_namelen) + \
'} -- {time:<9} (vs {loser})\n'
infotext = ''
for row in fastest_times:
if row[1] is None or row[2] is None:
continue
if row[3] is not None:
infotext += dated_format_str.format(winner=row[1],
time=racetime.to_str(row[0]),
loser=row[2],
date=row[3])
else:
infotext += undated_format_str.format(winner=row[1],
time=racetime.to_str(row[0]),
loser=row[2])
return infotext[:-1] if infotext else ''
async def parse_submission(self, daily_number: int, user_id: int,
args: list) -> str:
"""Attempt to parse args as a valid daily submission, and submits for the daily if sucessful.
Returns
-------
A string whose content confirms parse, or the empty string if parse fails.
"""
lv = level.LEVEL_NOS
time = -1
ret_str = ''
if len(args) > 0:
if args[0] == 'death':
if len(args) == 2:
lv = level.from_str(args[1])
if not lv == level.LEVEL_NOS:
ret_str = 'died on {}'.format(args[1])
else:
lv = level.LEVEL_UNKNOWN_DEATH
ret_str = 'died'
else:
time = racetime.from_str(args[0])
if not time == -1:
lv = level.LEVEL_FINISHED
ret_str = 'finished in {}'.format(racetime.to_str(time))
if not lv == level.LEVEL_NOS: # parse succeeded
await self.submit_to_daily(daily_number, user_id, lv, time)
return ret_str
else:
return ''
async def leaderboard_text(self, daily_number: int, display_seed=False):
"""The text (results) for the leaderboard"""
text = "``` \n"
text += self.leaderboard_header(daily_number) + '\n'
if display_seed:
for row in await dailydb.get_daily_seed(
daily_id=daily_number, daily_type=self.daily_type.value):
text += "Seed: {}\n".format(row[0])
break
no_entries = True
rank = int(0)
prior_result = '' # detect and handle ties
rank_to_display = int(1)
reverse_levelsort = dailytype.character(
daily_type=self.daily_type, daily_number=daily_number) == 'Aria'
daily_times = sorted(
await dailydb.get_daily_times(daily_id=daily_number,
daily_type=self.daily_type.value),
key=lambda x: level.level_sortval(int(x[1]),
reverse=reverse_levelsort),
reverse=True)
for row in daily_times:
name = strutil.tickless(row[0])
lv = row[1]
time = row[2]
if lv == level.LEVEL_FINISHED:
result_string = racetime.to_str(time)
elif lv == level.LEVEL_NOS:
continue
else:
result_string = level.to_str(lv)
if result_string == '':
result_string = "death"
else:
result_string = "death ({0})".format(result_string)
rank += 1
no_entries = False
# update the rank only if we've gotten a different result than the last entrant
if result_string != prior_result: # kinda hacky to use a string comparison here, but works
rank_to_display = rank
prior_result = result_string
text += '{0: >3}. {1: <24} {2}\n'.format(rank_to_display, name,
result_string)
if no_entries:
text += 'No entries yet.\n'
text += '```'
return text
async def get_fastest_times_infotext(category: Category, limit: int) -> str:
fastest_times = await racedb.get_fastest_times_leaderboard(category.name.lower(), limit)
infotext = '{0:>20} {1:<9} {2:<9} {3:<13}\n'.format('', 'Time (rta)', 'Seed', 'Date')
for row in fastest_times:
infotext += '{0:>20.20} {1:>9} {2:>9} {3:>13}\n'.format(
row[0],
racetime.to_str(int(row[1])),
row[2],
row[3].strftime("%b %d, %Y"))
return infotext
async def get_fastest_times_infotext(ndchar: NDChar, amplified: bool,
limit: int) -> str:
fastest_times = await racedb.get_fastest_times_leaderboard(
str(ndchar), amplified, limit)
infotext = '{0:>20} {1:<9} {2:<9} {3:<13}\n'.format(
'', 'Time (rta)', 'Seed', 'Date')
for row in fastest_times:
infotext += '{0:>20.20} {1:>9} {2:>9} {3:>13}\n'.format(
row[0], racetime.to_str(int(row[1])), row[2],
row[3].strftime("%b %d, %Y"))
return infotext
def _status_str(self, short: bool) -> str:
status = ''
if self._state == RacerStatus.finished:
status += racetime.to_str(self.time)
if not self.igt == FIELD_UNKNOWN and not short:
status += ' (igt {})'.format(racetime.to_str(self.igt))
else:
status += str(self._state)
if self._state == RacerStatus.forfeit and not short:
status += ' (rta {}'.format(racetime.to_str(self.time))
if 0 < self.level < 22:
status += ', ' + level.to_str(self.level)
if not self.igt == FIELD_UNKNOWN:
status += ', igt {}'.format(racetime.to_str(self.igt))
status += ')'
if not self.comment == '' and not short:
status += ': ' + self.comment
return status
def convert_score_to_text(category_race_info_descriptor: str,
score: int) -> Optional[str]:
time_categories = [
'CoH: Story (any%)', 'CoH: Story (all instruments)', 'CoH: Permadeath',
'CoH: Double Tempo'
]
if category_race_info_descriptor in time_categories:
return racetime.to_str(score)
elif category_race_info_descriptor == 'CoH: Fixed Beat':
return str(score)
else:
return None
def stdev_str(self) -> str:
if self.has_wins:
return racetime.to_str(int(self.stdev))
else:
return '--'
def mean_str(self) -> str:
if self.has_wins:
return racetime.to_str(int(self.mean))
else:
return '--'
def time_str(self) -> str:
return racetime.to_str(self.time)
def current_time_str(self) -> str:
current_time_ = self.current_time
if current_time_ is not None:
return racetime.to_str(current_time_)
else:
return ''
def avg_win_str(self):
return racetime.to_str(
self.average) if self.average is not None else '--'
def best_win_str(self):
return racetime.to_str(self.best) if self.best is not None else '--'
