Plataforma de entrenamiento para corredores: planes de 5K a maratón, registro de entrenamientos, hidratación, competencias y evolución. Versión beta en desarrollo.
Free UFC DFS optimizer and MMA fight simulator for DraftKings. Live win probabilities for every lineup, plus post-contest EV, ownership, and optimal lineups.
Weekly college football score projections, picks against the line, kickoff weather and quarterback status.
New projectSports & fitness
Do you operate this project?
Owners of public repositories under a personal GitHub account can sign in to verify ownership and manage the introduction themselves. No administrator approval is needed.
Organization repository · verify with a repository file
Sign in, generate a verification file, and commit it to this repository’s default branch within 30 minutes. Files on other branches or forks do not count. Then check the file below to manage the project without administrator approval. Keep the file to retain your access.
If needed, you will go to sign-in. After signing in, return here and press your chosen verification button again.
Run /nomorevibe verify in your project folder to verify ownership and manage the introduction yourself.
A stats-first football betting research project: does positive expected
value (ROI) vs. bookmaker closing odds exist anywhere in these markets, and
if so, where exactly? Not "does this predict football well" — a model can be
accurate and still lose money once the market's own margin is priced in.
Every claimed edge here has been walk-forward backtested (never trained on
future data) and calibration-checked before being trusted. Most markets
tested show no edge, and that's reported just as loudly as the ones that
do — see Results at a glance and the full
RESULTS.md.
Live dashboard
footymodel.vercel.app
— public view of the Premier League SofaScore paper-trading pipeline:
player shots/SOT and goals Over/Under 2.5. Tabs: Predictions,
Goals O/U, Track record (graded actuals + €100 paper bankroll when
synced from the repo), Features, and Glossary. Paper-trade only; no
login.
best config +2.05% yield but −1.52% CLV — the "positive yield, negative CLV" noise trap
Lineup-aware total-goals accuracy
✅ Confirmed
pooled t = 3.04 across all big-5 leagues
Closing-line goals O/U (historical)
❌ No edge
see row above; live path is lineup-window paper only
Lineup-edge → live goals paper
🔴 Active (hypothesis)
SofaScore match O/U + shared €100 ledger — live_recommendations.csv
Player shots/SOT calibration
✅ Well-calibrated
gaps mostly within ±0.03, full PL + Bundesliga seasons
Player shots/SOT → live paper
🔴 Active
same bankroll — dashboard + paper_bankroll_bets.csv
Full detail, per-league tables, and every rejected hypothesis (rest-days,
mid-tier lineup extension, etc.) are in RESULTS.md.
Core idea
Betting favorites gives a high hit rate and negative returns. We optimize for
edge vs. the bookmaker's margin-stripped ("fair") probability. Profit comes
from calibration + value detection + staking discipline, on top of a principled
statistical core (Dixon-Coles / Poisson).
Architecture
Production (live) — player shots/SOT + goals O/U 2.5, zero paid live APIs:
Research / legacy (not used in production): Dixon-Coles closing-line backtests,
recommend.py, API-Football / RapidAPI / Apify engines — see RESULTS.md.
The dashboard reads committed files from the repo (no separate database).
Props polling must run on a home IP (laptop script or self-hosted runner);
see docs/SHOTS_SOT_OPERATING.md.
Layout
footymodel/
config.py # leagues, seasons, data source URLs, column maps
data.py # Phase 1 — download + normalize football-data.co.uk CSVs
players.py # Phase A — LineupModel (confirmed-lineup goals prediction)
live/ # Phase B — live detection/paper-trade pipeline
sofascore_matchday.py # **production** — one poll: goals then props
sofascore_props_engine.py # PL player props + paper bets
sofascore_engine.py # lineup-aware goals O/U + paper bets
paper_bankroll.py # shared €100 ledger + staking
paper_props_bankroll.py # re-export shim
sofascore_props_odds.py # SofaScore player-prop odds (when exposed)
shots_engine.py # shots/SOT models + row builder
calendar.py # FPL calendar + idle-poll gate
fpl_client.py # free PL fixture feed
match_detail.py # JSONL: lineups + breakdown
engine.py / rapidapi_engine.py / apify_engine.py # legacy, not production
docs/
SHOTS_SOT_OPERATING.md # match-week playbook (start here)
PAPER_PROPS_EXPERIMENT.md # € bankroll rules
SELF_HOSTED_PROPS.md # laptop vs self-hosted runner
MATCHDAY_AUTOMATION.md # cron + calendar gate
dashboard/ # Next.js app (Vercel) — props + goals O/U public UI
data/
raw/ # downloaded CSVs (gitignored)
processed/ # normalized tidy tables + live logs (mostly gitignored,
# tracked exceptions listed in .gitignore for the cron to
# commit back to the repo)
requirements.txt is the production lock file. Update dependency ranges in
requirements.in, then regenerate it with
uv pip compile requirements.in --output-file requirements.txt --python-version 3.11.
SofaScore props polling also needs Playwright Chromium:
playwright install chromium
Live SofaScore paper trading (production)
Scope: Premier League only. Markets: player shots (1+/2+/3+),
SOT (1+/2+), and Over/Under 2.5 goals (lineup-aware). One internal
€100 paper bankroll (paper_props_bankroll.json, ledger paper_bankroll_bets.csv).
Output: data/processed/matches.parquet — one tidy row per match.
Historical — goals O/U recommender
Not part of the live product. Kept for backtests and paper_trades.csv
demos on historical football-data.co.uk odds.
The recommender fits the model on all history and outputs O/U value bets with
fractional-Kelly stakes for upcoming fixtures, logging them for paper-trading.
. .venv/bin/activate
# Demo on the latest matchday in the dataset (grades vs actual results):
python -m footymodel.recommend --league E1
# Live use next season — supply current fixtures + odds:
# fixtures.csv columns: home_team,away_team,odds_over25,odds_under25
python -m footymodel.recommend --league E1 --fixtures fixtures.csv
Every run appends to data/processed/paper_trades.csv. Team names must match
football-data.co.uk spellings (e.g. "Sheffield United", "Nott'm Forest").
HONEST STATUS. The goals/xG statistical model shows no edge vs. the
market (RESULTS.md): O/U yield ~−7%, CLV ~−0.2%. The one confirmed
exception is the lineup-aware model (Phase A below) — knowing the
actual starting XI (attack + defence) measurably improves O/U prediction
accuracy, replicated significantly across all 5 big-5 leagues (pooled
t=3.04). Live lineup-window goals O/U is paper-traded on SofaScore (see
Live SofaScore paper trading); closing-line
backtests above remain the honest baseline.
Phase A — lineup-aware model (research)
players.py's LineupModel predicts total goals from the actual starting XI
(both attack AND defence ratings, not team averages) using scraped Understat
per-match rosters. This is the single model improvement that has held up under
rigorous cross-league testing in this project — see RESULTS.md for the full
big-5 confirmation (every league improved in the same direction, unlike an
earlier half-built version that didn't replicate).
Home network:sofascore_props_engine.py via matchday_laptop.sh or
live_poll_props_selfhosted.yml.
See docs/SELF_HOSTED_PROPS.md. Optional .env
keys (API_FOOTBALL_KEY, RAPIDAPI_KEY, APIFY_TOKEN) are documented in
.env.example but not required for the props product.
Legacy dry-runs (mocked APIs, no quota):
python scripts/shots_live_dryrun.py
python scripts/live_dryrun.py # goals engine only
python scripts/run_all_dryrun.py
Checking performance
Dashboard → Track record: graded props vs Understat + € paper bankroll when ledger files are in the repo.
Phase A — lineup-aware model (players.py) → confirmed edge, t=3.04
Phase B — live lineup pipeline (live/) → live in production, polling
via GitHub Actions every 20min
Phase C — Asian Handicap, all 7 leagues (model.pypredict_ah,
scripts/ah_backtest.py) → no edge (best config: +2.05% yield but
CLV −1.52%, the "positive yield/negative CLV = noise" trap). Mid-tier
lineup extension via FBref researched and confirmed not viable (no
per-player xG for Championship/Eredivisie) — see RESULTS.md.
Phase D — Player shots-on-target via FBref (footymodel/fbref.py,
scripts/fbref_ingest_batch.py, scripts/fbref_sot_calibration_test.py)
→ well-calibrated on one PL season (gaps within ±0.03 in populated
buckets). See RESULTS.md Phase D.
Phase E — Player shots + SOT via WhoScored, real per-player minutes
(footymodel/whoscored.py, scripts/whoscored_calibration_test.py)
→ well-calibrated, full 380/380 PL 2023/24 season. See RESULTS.md
Phase E.
Phase F — Home/away venue factor for shots/SOT →
(~26%/22% higher home shots/SOT rate league-wide on PL). See RESULTS.md
Phase F.
Testing
Most of this project's real correctness checks are backtests, not unit
tests — a walk-forward calibration table catches more than an assert would.
But a handful of non-trivial, data-independent logic paths do have
standalone pure-Python checks, run on every push via
GitHub Actions:
Everything under live/ additionally has a dry-run mode (mocked API
responses, no key or quota spent) — see
Before spending API quota above.
The dashboard (TypeScript, no test framework) is verified via npx tsc --noEmit and npm run build on every change.
Phase G — Second-league robustness check (Bundesliga) → venue effect
and calibration both replicate with zero re-tuning. See RESULTS.md
Phase G.
Phase H — Merged live cron entry point (live/run_all.py) → goals and
player-props engines now share ONE fixtures+lineups fetch per poll
instead of two independent ones, which would have doubled API-Football
usage past the Free-tier daily quota.
Phase I — Player-prop odds wired into shots_engine.py, same
API-Football key as everything else. Forward paper-trade only (no
historical prop-odds archive is reachable).
Phase J — Multi-source live resilience → added rapidapi_engine.py
and sofascore_engine.py as fallbacks after API-Football's free tier
was suspended once without warning (all three log to the same CSV,
tagged by source); moved production polling from a local crontab to a
GitHub Actions cron (live_poll.yml) so nothing depends on a machine
staying on. SofaScore's fallback currently blocked by bot-detection on
GitHub's shared runner IPs specifically — tracked, non-blocking.
Phase K — Public dashboard (dashboard/) → Next.js app on Vercel,
reading live data straight from this (private) repo via the GitHub
Contents API. Five tabs (Track record, Goals O/U, Player props,
Staking, Glossary); expandable match cards showing the team-model vs.
lineup-model breakdown and starting XI behind each Goals O/U
prediction (live/match_detail.py logs the extra data, previously
computed and discarded); mobile-responsive; past-kickoff predictions
collapse into a "show N past predictions" disclosure instead of either
cluttering the upcoming list or disappearing entirely.
Phase L — Scheduled training-data refresh (refresh_training_data.yml)
→ nothing was keeping matches.parquet/matches_xg.parquet/
player_match.parquet current as the season progressed. Now runs
daily in GitHub Actions, no laptop involved: full big-5 season history
for match results/base xG (cheap, one request per league-season), but
build_players.py's per-match Understat roster scrape only refreshes
the current season - re-scraping the full history daily would be
thousands of redundant requests. Required fixing build_players.py to
merge the refreshed season into the existing file instead of
overwriting it wholesale (merge_player_dataset(), unit tested).
Phase M — Saved PL fixture calendar (live/calendar.py) → daily
10-day kickoff snapshot so the dashboard can preview next weekend
during a quiet midweek, idle live_poll ticks skip Playwright/API
lineup fetches, and a delayed poll still queries yesterday when an
unseen fixture sits in the 24h backward window. Missing/stale
calendar fails open (runs the engines) rather than risking a miss.
