Do teams struggle after an international break?

# From Football Data Science by Bryan McGuire. Free to use with credit.
# https://www.footballdatascience.co.uk/myth-or-maths/international-break
import csv
from collections import Counter, defaultdict
from datetime import date, datetime
from math import sqrt

def when(d):
    return datetime.strptime(d, "%d/%m/%Y" if len(d) == 10 else "%d/%m/%y").date()

def points(goals_for, goals_against):
    return 3 if goals_for > goals_against else 1 if goals_for == goals_against else 0

matches = []
for y in range(2000, 2026):
    with open(f"SC0_{y % 100:02d}{(y + 1) % 100:02d}.csv", encoding="latin-1") as f:  # Premiership
        for r in csv.DictReader(f):
            if r.get("FTR") not in ("H", "D", "A"):
                continue
            try:  # Bet365 odds turned into probabilities that add up to 1 (from 2002/03)
                p = [1 / float(r["B365" + k]) for k in "HDA"]
                p = [v / sum(p) for v in p]
            except (KeyError, ValueError, ZeroDivisionError):
                p = None
            matches.append((when(r["Date"]), r["HomeTeam"].strip(), r["AwayTeam"].strip(), int(r["FTHG"]), int(r["FTAG"]), p))

# International breaks: the league stopped for 12 to 21 days and restarted just after an international window.
# Left out: the winter break, April cup semi-finals, snow in 2010 and the postponements of September 2022.
def after_window(d):
    return ((d.month == 9 and d.day <= 20) or (d.month == 10 and (d.day <= 2 or 10 <= d.day <= 25))
            or (d.month == 11 and 15 <= d.day <= 28) or (d.month == 3 and d.day >= 25) or (d.month == 4 and d.day <= 12))

days = sorted({m[0] for m in matches})
restarts = [b for a, b in zip(days, days[1:]) if 12 <= (b - a).days <= 21 and after_window(b) and b != date(2022, 9, 17)]
print(f"{len(restarts)} international breaks; the league restarted on:", ", ".join(d.strftime("%d %b %Y") for d in restarts))
def first_back(m):  # both teams' first match since the restart, within a week of it
    d = max((r for r in restarts if r <= m[0]), default=None)
    return (d is not None and (m[0] - d).days <= 6
            and not any(d <= x[0] < m[0] and {x[1], x[2]} & {m[1], m[2]} for x in matches))
after = [m for m in matches if first_back(m)]
other = [m for m in matches if m not in after]
print(f"{len(after)} matches straight after a break, {len(other)} others")

def share(rows, test):
    p = sum(map(test, rows)) / len(rows)
    return f"{p:.1%} (±{1.96 * sqrt(p * (1 - p) / len(rows)):.1%})"

def average(values):
    mean = sum(values) / len(values)
    return mean, 1.96 * sqrt(sum((v - mean) ** 2 for v in values) / (len(values) - 1) / len(values))

for name, rows in (("after a break", after), ("other matches", other)):
    goals, margin = average([m[3] + m[4] for m in rows])
    print(f"{name}: home {share(rows, lambda m: m[3] > m[4])}, draw {share(rows, lambda m: m[3] == m[4])}, "
          f"away {share(rows, lambda m: m[3] < m[4])}, goals {goals:.2f} (±{margin:.2f})")

def against_odds(m, team):
    """Points the team earned minus the points the bookmakers expected it to earn."""
    _, home, away, hg, ag, p = m
    if team == home:
        return points(hg, ag) - (3 * p[0] + p[1])
    return points(ag, hg) - (3 * p[2] + p[1])

def favourite(m):
    return m[1] if m[5][0] >= m[5][2] else m[2]

old_firm = {"Celtic", "Rangers"}
for label, keep in (("all clubs", lambda m: True), ("without Celtic and Rangers", lambda m: not old_firm & {m[1], m[2]})):
    for name, rows in (("after a break", after), ("other matches", other)):
        gaps = [against_odds(m, favourite(m)) for m in rows if m[5] and keep(m)]
        mean, margin = average(gaps)
        print(f"favourites v the odds, {label}, {name}: {mean:+.2f} points a game (±{margin:.2f}, {len(gaps)} matches)")

for club in sorted(old_firm):
    for name, rows in (("after a break", after), ("other matches", other)):
        mine = [m for m in rows if club in m[1:3]]
        ppg, margin = average([points(m[3], m[4]) if club == m[1] else points(m[4], m[3]) for m in mine])
        print(f"{club}, {name}: {ppg:.2f} points a game (±{margin:.2f}, {len(mine)} matches)")

# Club by club: each club's results against the odds after a break, minus its results against the odds otherwise
print("\nclub by club, after a break minus usual, points a game against the odds (clubs with 15+ matches after a break):")
clubs = Counter(t for m in after for t in m[1:3])
rows, outside = [], 0
for club, n in clubs.items():
    if n < 15:
        continue
    a, ea = average([against_odds(m, club) for m in after if club in m[1:3] and m[5]])
    b, eb = average([against_odds(m, club) for m in other if club in m[1:3] and m[5]])
    margin = sqrt(ea ** 2 + eb ** 2)
    rows.append((a - b, margin, club, n))
    outside += abs(a - b) > margin
for gap, margin, club, n in sorted(rows):
    print(f"  {club:<14} {gap:+.2f} (±{margin:.2f}, {n} matches)")
print(f"{outside} of {len(rows)} clubs outside the luck margin; about {0.05 * len(rows):.1f} expected by luck alone")

# Why fans believe it: the longest run of post-break games without a win, for any club
def longest_runs(results):
    """results: (date, home, away, outcome) in date order -> each club's longest run without a win, and when it ended."""
    run, best = Counter(), {}
    for d, home, away, outcome in results:
        for club, won in ((home, outcome == "H"), (away, outcome == "A")):
            run[club] = 0 if won else run[club] + 1
            if run[club] > best.get(club, (0,))[0]:
                best[club] = (run[club], d)
    return best

real = longest_runs([(m[0], m[1], m[2], "H" if m[3] > m[4] else "D" if m[3] == m[4] else "A") for m in sorted(after)])
n, club = max((v[0], c) for c, v in real.items())
print(f"\nlongest run of games without a win straight after a break: {club}, {n}, ending {real[club][1]:%B %Y}")

# If breaks made no difference, how often would some club have a run that long? Draw every post-break result
# from the bookmakers' odds and look for the longest run in the league, 2,000 times (matches with odds only).
import random
random.seed(1)
priced = [m for m in sorted(after) if m[5]]
def draw(p):
    u = random.random()
    return "H" if u < p[0] else "D" if u < p[0] + p[1] else "A"
hits = sum(max(v[0] for v in longest_runs([(m[0], m[1], m[2], draw(m[5])) for m in priced]).values()) >= n
           for _ in range(2000))
print(f"with no break effect at all, some club has a run of {n} or more in {hits / 2000:.0%} of simulated histories")