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]))