def footer(ctx):
"""Return a footer with some general information and hidden logs."""
tokens = [
md.link("^Source", consts.repo_url),
md.link("^Developer", consts.me),
]
# TODO: Add usage instructions link when commands are ready.
# if random.random() < consts.promo_rate:
# tokens.append(md.link(
# "^([Unnoticed]: Unranked leaderboards)",
# consts.unnoticed,
# ))
exp_pp = bool(ctx.beatmap) and ctx.beatmap.mode.value != ctx.mode
exp_pp |= ctx.mode in [consts.ctb, consts.mania]
if exp_pp:
if ctx.mode == consts.taiko:
mode = "Autoconverted "
else:
mode = ""
mode += consts.mode2str[ctx.mode]
tokens.append("^(%s pp is experimental)" % mode)
text = "^(%s – )%s" % (random.choice(consts.memes), "^( | )".join(tokens))
logs = md.link( # Invisible link with hover text.
consts.spc,
'http://x "%s"' % "\n".join(s.replace('"', "'") for s in ctx.logs),
)
return "%s %s" % (text, logs)
def get_benchmark_result_markdown(benchmark_files: Sequence[str],
query_base: bool,
verbose: bool = False) -> Tuple[str, str]:
"""Gets the full/abbreviated markdown summary of all benchmarks in files."""
all_benchmarks = aggregate_all_benchmarks(benchmark_files)
build_url = get_required_env_var("BUILDKITE_BUILD_URL")
pr_number = get_required_env_var("BUILDKITE_PULL_REQUEST")
pr_commit = get_required_env_var("BUILDKITE_COMMIT")
pr_commit = md.link(pr_commit,
f"{GITHUB_IREE_REPO_PREFIX}/commit/{pr_commit}")
commit_info = f"@ commit {pr_commit}"
if query_base:
# Try to query some base benchmark to diff against, from the top of the
# tree. Bail out if the maximal trial number is exceeded.
for i in range(MAX_BASE_COMMIT_QUERY_COUNT):
base_commit = get_origin_tree_commit(i, verbose)
base_benchmarks = query_base_benchmark_results(base_commit, verbose)
base_commit = md.link(base_commit,
f"{GITHUB_IREE_REPO_PREFIX}/commit/{base_commit}")
if len(base_benchmarks) == 0:
commit_info = (f"@ commit {pr_commit} (no previous benchmark results to"
f" compare against since {base_commit})")
continue
# Update the aggregate benchmarks with base numbers.
for bench in base_benchmarks:
if bench in all_benchmarks:
all_benchmarks[bench].base_mean_time = base_benchmarks[bench]
commit_info = f"@ commit {pr_commit} (vs. base {base_commit})"
break
pr_info = md.link("Pull request",
f"{GITHUB_IREE_REPO_PREFIX}/pull/{pr_number}")
buildkite_info = md.link("Buildkite build", build_url)
# Compose the full benchmark tables.
full_table = [md.header("Full Benchmark Summary", 2)]
full_table.append(md.unordered_list([commit_info, pr_info, buildkite_info]))
full_table.append(
categorize_benchmarks_into_tables(all_benchmarks,
SIMILAR_BECNHMARK_THRESHOLD))
# Compose the abbreviated benchmark tables.
abbr_table = [md.header(ABBR_PR_COMMENT_TITLE, 2)]
abbr_table.append(commit_info)
abbr_table.append(
categorize_benchmarks_into_tables(all_benchmarks,
SIMILAR_BECNHMARK_THRESHOLD,
TABLE_SIZE_CUT))
abbr_table.append("For more information:")
# We don't know until a Gist is really created. Use a placeholder for now
# and replace later.
full_result_info = md.link("Full benchmark result tables",
"<<placeholder-link>>")
abbr_table.append(md.unordered_list([full_result_info, buildkite_info]))
return "\n\n".join(full_table), "\n\n".join(abbr_table)
def blocklist_section_table(list_sources):
"""The table for the blocklist README.md file."""
tbl_col_tup = namedtuple("tbl_col_tup", "c1, c2, c3, c4")
tbl_col_arr = ["#", "TITLE", "DESCRIPTION", "DOWNLOAD LINK"]
tbl_col = tbl_col_tup(*tbl_col_arr)
tbl_pad_arr = [
len("---"),
len(tbl_col.c2),
len(tbl_col.c3),
len(tbl_col.c4),
]
table_contents = []
tbl_pad = tbl_col_tup(*tbl_pad_arr)
for index, file in enumerate(list_sources):
blg = ListGenerator(
file_json=file,
)
filter_list_link = markdown_strings.link(
f"{blg.info.home}/filters/{blg.category}.txt",
f"{blg.info.home}/filters/{blg.category}.txt",
)
if len(str(index + 1).zfill(2)) > tbl_pad.c1:
tbl_pad_arr[0] = len(str(index + 1).zfill(2)) + 2
if len(str(blg.data_json[blg.j_key.title])) > tbl_pad.c2:
tbl_pad_arr[1] = len(str(blg.data_json[blg.j_key.title])) + 2
if len(str(blg.data_json[blg.j_key.desc])) > tbl_pad.c3:
tbl_pad_arr[2] = len(str(blg.data_json[blg.j_key.desc])) + 2
if len(str(filter_list_link)) > tbl_pad.c4:
tbl_pad_arr[3] = len(str(filter_list_link)) + 2
tbl_pad = tbl_col_tup(*tbl_pad_arr)
for index, file in enumerate(list_sources):
blg = ListGenerator(
file_json=file,
)
filter_list_link = markdown_strings.link(
f"{blg.info.home}/filters/{blg.category}.txt",
f"{blg.info.home}/filters/{blg.category}.txt",
)
row = markdown_strings.table_row(
[
str(index + 1).zfill(2),
str(blg.data_json[blg.j_key.title]),
str(blg.data_json[blg.j_key.desc]),
str(filter_list_link),
],
[tbl_pad.c1, tbl_pad.c2, tbl_pad.c3, tbl_pad.c4],
)
table_contents.append(row)
table_delimiter = markdown_strings.table_delimiter_row(
4, column_lengths=[tbl_pad.c1, tbl_pad.c2, tbl_pad.c3, tbl_pad.c4]
)
table_title_row = markdown_strings.table_row(
[tbl_col.c1, tbl_col.c2, tbl_col.c3, tbl_col.c4],
[tbl_pad.c1, tbl_pad.c2, tbl_pad.c3, tbl_pad.c4],
)
return [table_title_row, table_delimiter, "\n".join(table_contents)]
def category_section_main(blg, stats):
"""Generates the main section of the category README.md file."""
value_percentage = float(
(
(int(stats["unprocessed"]) - int(stats["processed"]))
/ int(stats["unprocessed"])
)
* 100
)
link_filter = markdown_strings.link(
"Download",
f"{blg.info.home}/filters/{blg.category}.txt",
)
main_title = (
markdown_strings.header(f"{blg.data_json[blg.j_key.title]}", 1)
+ "\n"
+ "**"
+ link_filter
+ "**"
)
main_desc = markdown_strings.bold(f"{fill(blg.data_json[blg.j_key.desc])}")
info_list = [
f"Sources: {len(blg.data_json[blg.j_key.sources])}",
f"""Rules before processing: {stats["unprocessed"]}""",
f"""Rules after processing: {stats["processed"]}""",
]
info_add = markdown_strings.unordered_list(info_list)
string_bold = (
f"aBL - {blg.data_json[blg.j_key.title]} is {value_percentage:.2f}% lighter"
)
sub_desc = f"The {markdown_strings.bold(string_bold)} than its combined sources"
return [main_title, main_desc, info_add, sub_desc]
def map_header(ctx):
"""Return a line or two with basic map information."""
if not ctx.beatmap:
return None
b = ctx.beatmap
map_url = "%s/b/%d" % (consts.osu_url, b.beatmap_id)
if ctx.mode is not None:
map_url += "?m=%d" % ctx.mode
map_link = md.link(escape(map_str(b)), map_url)
mapper_id = scrape.mapper_id(ctx)
mapper = b.creator if mapper_id is None else mapper_id
mapper_url = "%s/u/%s" % (consts.osu_url, mapper)
rename = mapper_renamed(ctx, mapper_id=mapper_id)
hover = "Renamed to '%s'" % rename if rename is not None else ""
counts = mapper_counts(ctx, mapper=mapper)
if counts:
hover += ": %s" % counts if hover else counts
if hover:
mapper_url += ' "%s"' % hover
mapper_link = md.link(escape(b.creator), mapper_url)
map_s = "%s by %s" % (map_link, mapper_link)
if ctx.guest_mapper:
guest_url = "%s/u/%d" % (consts.osu_url, ctx.guest_mapper.user_id)
counts = mapper_counts(ctx, mapper=ctx.guest_mapper.user_id)
if counts:
guest_url += ' "%s"' % counts
guest_link = md.link(ctx.guest_mapper.username, guest_url)
map_s += " (GD by %s)" % guest_link
tokens = [map_s]
unranked = consts.int2status[b.approved.value] == "Unranked"
if not unranked and ctx.mode is not None:
tokens.append(consts.mode2str[ctx.mode])
header = md.header(" || ".join(tokens), 4)
subheader = (unranked_subheader if unranked else approved_subheader)(ctx)
return "%s\n%s" % (header, subheader)
def category_section_table(blg):
"""Generates the table for the category README.md file."""
tbl_col_tup = namedtuple("tbl_col_tup", "c1, c2, c3, c4, c5")
tbl_col_arr = [
"#",
"Title",
"Description",
"Blocking rules",
"Unblocking rules",
]
tbl_col = tbl_col_tup(*tbl_col_arr)
tbl_pad_arr = [
len("---"),
len(tbl_col.c2),
len(tbl_col.c3),
len(tbl_col.c4),
len(tbl_col.c5),
]
tbl_pad = tbl_col_tup(*tbl_pad_arr)
for index, key in enumerate(blg.data_json[blg.j_key.sources]):
if len(str({index + 1}).zfill(2)) > tbl_pad.c1:
tbl_pad_arr[0] = len(str({index + 1}).zfill(2)) + 2
if len(str(f"[{key[blg.i_key.name]}]({key[blg.i_key.url]})")
) > tbl_pad.c2:
tbl_pad_arr[1] = (
len(str(f"[{key[blg.i_key.name]}]({key[blg.i_key.url]})")) + 2)
if len(str({key[blg.i_key.desc]})) > tbl_pad.c3:
tbl_pad_arr[2] = len(str({key[blg.i_key.desc]})) + 2
if len(str({key[blg.i_key.num_block_rules]})) > tbl_pad.c4:
tbl_pad_arr[3] = len(str({key[blg.i_key.num_block_rules]})) + 2
if len(str({key[blg.i_key.num_unblock_rules]})) > tbl_pad.c5:
tbl_pad_arr[4] = len(str({key[blg.i_key.num_unblock_rules]})) + 2
tbl_pad = tbl_col_tup(*tbl_pad_arr)
table_title_row = markdown_strings.table_row(
[tbl_col.c1, tbl_col.c2, tbl_col.c3, tbl_col.c4, tbl_col.c5],
[tbl_pad.c1, tbl_pad.c2, tbl_pad.c3, tbl_pad.c4, tbl_pad.c5],
)
table_delimiter = markdown_strings.table_delimiter_row(
5,
column_lengths=[
tbl_pad.c1, tbl_pad.c2, tbl_pad.c3, tbl_pad.c4, tbl_pad.c5
],
)
table_contents = []
for index, key in enumerate(blg.data_json[blg.j_key.sources]):
link = markdown_strings.link(key[blg.i_key.name], key[blg.i_key.url])
row = markdown_strings.table_row(
[
str(index + 1).zfill(2),
link,
key[blg.i_key.desc],
key[blg.i_key.num_block_rules],
key[blg.i_key.num_unblock_rules],
],
[tbl_pad.c1, tbl_pad.c2, tbl_pad.c3, tbl_pad.c4, tbl_pad.c5],
)
table_contents.append(row)
return [table_title_row, table_delimiter, "\n".join(table_contents)]
def map_rank_one(ctx):
"""Fetch and format the top play for a beatmap."""
if not ctx.beatmap:
return None
mode = ctx.mode if ctx.mode is not None else consts.std
apimode = consts.int2osuapimode[mode]
scores = safe_call(
consts.osu_api.get_scores,
ctx.beatmap.beatmap_id,
mode=apimode,
limit=2,
)
if not scores:
return None
score = scores[0]
use_two = bool(ctx.player) and score.user_id == ctx.player.user_id
use_two &= score.enabled_mods.value == ctx.mods
if use_two and len(scores) > 1:
score = scores[1]
players = safe_call(consts.osu_api.get_user, score.user_id, mode=apimode)
if players:
ctx_clone = copy.deepcopy(ctx)
ctx_clone.player = players[0]
hover = player_hover(ctx_clone, oldplayer=ctx.player)
else:
hover = None
player_url = "%s/u/%s" % (consts.osu_url, score.user_id)
if hover:
player_url += ' "%s"' % hover
player_link = md.link(escape(score.username), player_url)
player = "#%d: %s" % (2 if use_two else 1, player_link)
tokens = []
if score.enabled_mods.value != consts.nomod:
tokens.append(combine_mods(score.enabled_mods.value))
tokens.append("%.2f%%" % accuracy(score, mode))
if score.pp is not None:
tokens.append("%spp" % sep(round(score.pp)))
return "%s (%s)" % (player, " - ".join(tokens))
def _make_benchmark_clickable(name: str) -> str:
"""Add link to the given benchmark name."""
url = PERFBOARD_SERIES_PREFIX + urllib.parse.quote(name, safe="()[]@,")
return md.link(name, url)
def link(self, url, text=""):
return markdown_strings.link(text, url)
def player_table(ctx):
"""Build a table with player information."""
if not ctx.player:
return None
p = ctx.player
if not p.pp_raw: # Player is inactive so most stats are null.
return None
rank = "#%s (#%s %s)" % (sep(p.pp_rank), sep(p.pp_country_rank), p.country)
player_url = "%s/u/%d" % (consts.osu_url, p.user_id)
old_username = scrape.player_old_username(ctx)
if old_username and old_username.lower() != p.username.lower():
player_url += " \"Previously known as '%s'\"" % old_username
player_link = md.link(nonbreaking(escape(p.username)), player_url)
cols = [
["Player", player_link],
["Rank", nonbreaking(rank)],
["pp", sep(round(p.pp_raw))],
["Accuracy",
"%s%%" % round_to_str(p.accuracy, 2, force=True)],
["Playcount", sep(p.playcount)],
]
# There's no point getting playstyle for non-standard players.
playstyle = scrape.playstyle(ctx) if ctx.mode == consts.std else None
if playstyle is not None:
cols.insert(4, ["Playstyle", playstyle]) # Place after acc.
mode = ctx.mode if ctx.mode is not None else consts.std
scores = safe_call(
consts.osu_api.get_user_best,
ctx.player.user_id,
mode=consts.int2osuapimode[mode],
limit=1,
)
if scores:
score = scores[0]
beatmaps = safe_call(
consts.osu_api.get_beatmaps,
beatmap_id=score.beatmap_id,
mode=consts.int2osuapimode[mode],
include_converted=True,
)
if beatmaps:
bmap = beatmaps[0]
map_url = "%s/b/%d" % (consts.osu_url, bmap.beatmap_id)
if ctx.mode is not None:
map_url += "?m=%d" % ctx.mode
ctx_clone = copy.deepcopy(ctx)
ctx_clone.beatmap = bmap
ctx_clone.mods = score.enabled_mods.value
ctx_clone.mode = mode
hover = map_hover(ctx_clone, oldmap=ctx.beatmap, oldmods=ctx.mods)
if hover:
map_url += ' "%s"' % hover
map_link = md.link(nonbreaking(escape(map_str(bmap))), map_url)
mods = combine_mods(score.enabled_mods.value)
buf = "%s %s " % (mods, consts.bar) if mods else ""
buf += "%s%%" % round_to_str(accuracy(score, mode), 2, force=True)
if score.pp:
buf += " %s %spp" % (consts.bar, sep(round(score.pp)))
cols.append(["Top Play", "%s %s" % (map_link, nonbreaking(buf))])
return centre_table(md.table([[str(x) for x in col] for col in cols]))
