Install at least Python 3.10 (because of the new typing union `|`, if you cannot do so you can

change the `type1 | type2` annotations to `Union[type1, type2]`).

Install the requirements (`pillow` for creating images, `requests` for the leaderboard data and `pyyaml` to parse the language config):

Now add `<!-- AOC TILES BEGIN -->` and `<!-- AOC TILES END -->` in your README, everything between these 2 tags

will always be replaced by the script, so do not add additional information there. Note that these are HTML comments,

so they will not be visible in the rendered README.

YEAR_PATTERN = r"\d{4}"

DAY_PATTERN = r"\d{2}"

def get_solution_paths_dict_for_years() -> dict[int, dict[int, list[str]]]:

"""Returns a dictionary which maps years to days to a list of solution paths,

solution_paths_dict: dict[int, dict[int, list[str]]] = {}

# If you use a new repo for years you might just remove this if, and assign the year manually

for year_dir in sorted(get_paths_matching_regex(AOC_DIR, YEAR_PATTERN), reverse=True):

year = find_first_number(year_dir.name)

solution_paths_dict[year] = {}

# If you have a deep structure then you can adjust the year dir as well:

# year_dir = year_dir / "src/main/kotlin/com/example/aoc"

for day_dir in get_paths_matching_regex(year_dir, DAY_PATTERN):

day = find_first_number(day_dir.name)

solutions = sorted(find_recursive_solution_files(day_dir))

# To filter by extension:

# solutions = [s for s in solutions if s.suffix == ".py"]

# To only show a single solution:

# solutions = [solutions[0]]

# To show tiles for days that have been completed but do not have a solution:

# if len(solutions) == 0:

# solutions = [Path("dummy.kt")]

solutions = [solution.relative_to(AOC_DIR) for solution in solutions]

solution_paths_dict[year][day] = [str(s) for s in solutions]

return solution_paths_dict

def find_recursive_solution_files(directory: Path) -> list[Path]:

solution_paths = []

for path in directory.rglob('*'):

if path.is_file() and path.suffix in extension_to_color:

solution_paths.append(path)

return solution_paths

def parse_leaderboard(leaderboard_path: Path) -> dict[int, DayScores]:

leaderboard[int(day)] = DayScores(*scores)

def request_leaderboard(year: int) -> dict[int, DayScores]:

def handle_day(day: int, year: int, solutions: list[str], html: HTML, day_scores: DayScores | None):

for solution in solutions:

extension = "." + solution.split(".")[-1]

if extension in extension_to_color and extension not in languages:

languages.append(extension)

solution_link = solutions[0] if solutions else None

with html.tag("a", href=str(solution_link)):

def fill_empty_days_in_dict(day_to_solutions: dict[int, list[str]], max_day) -> None:

if not CREATE_ALL_DAYS and len(day_to_solutions) == 0:

print(f"Current year has no solutions!")

for day in range(1, max_day + 1):

if day not in day_to_solutions:

day_to_solutions[day] = []

def handle_year(year: int, day_to_solutions: dict[int, list[str]]):

leaderboard[25] = None

leaderboard[24] = DayScores("22:22:22", "12313", "0")

day_to_solutions[23] = []

max_day = 25 if CREATE_ALL_DAYS else max(*day_to_solutions, *leaderboard)

fill_empty_days_in_dict(day_to_solutions, max_day)

for day, solutions in day_to_solutions.items():

handle_day(day, year, solutions, html, leaderboard.get(day, None))

for year, day_to_solutions_list in get_solution_paths_dict_for_years().items():

handle_year(year, day_to_solutions_list)

<a href="2022/01/01.kt">

<a href="2021/22/22.jl">

<a href="2021/24/24.cpp">