Loading Model Diagnostics...
;
+
+ // --- MATH HELPERS ---
+ const calcMetrics = (y_true, y_pred) => {
+ const n = y_true.length;
+ if (n === 0) return { rmse: 0, mae: 0, r2: 0 };
+
+ let sumErrSq = 0, sumErrAbs = 0, sumY = 0;
+ for (let i = 0; i < n; i++) {
+ sumErrSq += Math.pow(y_true[i] - y_pred[i], 2);
+ sumErrAbs += Math.abs(y_true[i] - y_pred[i]);
+ sumY += y_true[i];
+ }
+ const meanY = sumY / n;
+ let ssTot = 0;
+ for (let i = 0; i < n; i++) ssTot += Math.pow(y_true[i] - meanY, 2);
+
+ return {
+ rmse: Math.sqrt(sumErrSq / n),
+ mae: sumErrAbs / n,
+ r2: ssTot === 0 ? 0 : 1 - (sumErrSq / ssTot)
+ };
+ };
+
+ // --- OUTCOME ACCURACY MATH ---
+ let globalLL = 0, globalBrier = 0;
+ const trendData = [];
+
+ // --- GOALS & XG MATH ---
+ const actGoals = [], projGoals = [], actXG = [];
+ const scatterDataGoals = [], scatterDataXG = [];
+
+ if (matchData.length > 0) {
+ let totalMatches = 0;
+ const gwMap = matchData.reduce((acc, row) => {
+ (acc[row.GW] = acc[row.GW] || []).push(row);
+ return acc;
+ }, {});
+
+ Object.keys(gwMap).sort((a,b) => a-b).forEach(gw => {
+ const matches = gwMap[gw];
+ let gwLL = 0, gwBrier = 0;
+
+ matches.forEach(m => {
+ // Log loss
+ const p_h = Math.max(Math.min(m.home_win_prob, 1-1e-15), 1e-15);
+ const p_d = Math.max(Math.min(m.draw_prob, 1-1e-15), 1e-15);
+ const p_a = Math.max(Math.min(m.away_win_prob, 1-1e-15), 1e-15);
+
+ const ll = - ((m.home_win * Math.log(p_h)) + (m.draw * Math.log(p_d)) + (m.away_win * Math.log(p_a)));
+ gwLL += ll; globalLL += ll;
+
+ // Brier Score
+ const brier = Math.pow(p_h - m.home_win, 2) + Math.pow(p_d - m.draw, 2) + Math.pow(p_a - m.away_win, 2);
+ gwBrier += brier; globalBrier += brier;
+ totalMatches++;
+
+ // Goals & xG Collections
+ if (m.home_goals !== undefined && m.expected_home_goals !== undefined) {
+ actGoals.push(Number(m.home_goals));
+ projGoals.push(Number(m.expected_home_goals));
+ actXG.push(Number(m.xg_home));
+ scatterDataGoals.push({ proj: Number(m.expected_home_goals), act: Number(m.home_goals) });
+ scatterDataXG.push({ proj: Number(m.expected_home_goals), act: Number(m.xg_home) });
+
+ actGoals.push(Number(m.away_goals));
+ projGoals.push(Number(m.expected_away_goals));
+ actXG.push(Number(m.xg_away));
+ scatterDataGoals.push({ proj: Number(m.expected_away_goals), act: Number(m.away_goals) });
+ scatterDataXG.push({ proj: Number(m.expected_away_goals), act: Number(m.xg_away) });
+ }
+ });
+
+ trendData.push({ gw: `GW${gw}`, weeklyBrier: gwBrier / matches.length, cumBrier: globalBrier / totalMatches });
+ });
+ globalLL /= totalMatches;
+ globalBrier /= totalMatches;
+ }
+
+ const goalsMetrics = calcMetrics(actGoals, projGoals);
+ const xgMetrics = calcMetrics(actXG, projGoals);
+
+ // --- xMINS / xPTS MATH ---
+ let ptsMetrics = { rmse: 0, mae: 0, r2: 0 };
+ let minsMetrics = { rmse: 0, mae: 0, r2: 0 };
+
+ if (playerData.length > 0) {
+ const actPts = [], pPts = [], actMins = [], pMins = [];
+ playerData.forEach(p => {
+ for (let gw = 1; gw <= 38; gw++) {
+ if (p[`${gw}_xMins`] > 0 && p[`${gw}_Pts`] !== undefined && p[`${gw}_Actuals`] !== undefined) {
+ pPts.push(Number(p[`${gw}_Pts`]));
+ actPts.push(Number(p[`${gw}_Actuals`]));
+ pMins.push(Number(p[`${gw}_xMins`]));
+ actMins.push(Number(p[`${gw}_Mins`]) || 0);
+ }
+ }
+ });
+ ptsMetrics = calcMetrics(actPts, pPts);
+ minsMetrics = calcMetrics(actMins, pMins);
+ }
+
+ return (
+ Loading fixtures...
;
+
+ const { effectiveFixtures } = useContext(PlayerContext);
+
+ const TEAM_MAP = {
+ "Arsenal": 1, "Aston Villa": 2, "Burnley": 3, "AFC Bournemouth": 4, "Brentford": 5,
+ "Brighton": 6, "Chelsea": 7, "Crystal Palace": 8, "Everton": 9, "Fulham": 10,
+ "Leeds United": 11, "Liverpool": 12, "Man City": 13, "Manchester City": 13,
+ "Man Utd": 14, "Manchester United": 14, "Newcastle": 15, "Newcastle United": 15,
+ "Nott'm Forest": 16, "Nottingham Forest": 16, "Sunderland": 17,
+ "Spurs": 18, "Tottenham": 18, "Tottenham Hotspur": 18,
+ "West Ham": 19, "West Ham United": 19, "Wolves": 20, "Wolverhampton Wanderers": 20
+ };
+
+ const expandedFixtures = [];
+
+ fixtures.forEach(match => {
+ const hId = match.home_team_id || TEAM_MAP[match.home_team] || match.home_team;
+ const aId = match.away_team_id || TEAM_MAP[match.away_team] || match.away_team;
+ const matchId = `${hId}_vs_${aId}`;
+
+ const override = effectiveFixtures?.[matchId];
+
+ if (override) {
+ Object.entries(override).forEach(([gw, prob]) => {
+ // THE FIX: Prevent floating point ghost fixtures (must be >= 0.5%)
+ if (Number(prob) >= 0.005) {
+ expandedFixtures.push({ ...match, GW: Number(gw), shiftProb: Number(prob) });
+ }
+ });
+ } else {
+ expandedFixtures.push({ ...match, shiftProb: 1.0 });
+ }
+ });
+
+ const groupedFixtures = expandedFixtures.reduce((acc, match) => {
+ (acc[match.GW] = acc[match.GW] || []).push(match);
+ return acc;
+ }, {});
+
+ return (
+
+
+ {/* Minimal Top Bar for Load */}
+
+
+
+
+ {teamData.length > 0 ? (
+ <>
+
+ {/* Pitch Rendering wrapper */}
+
+
+
+
+ {/* STATS ROW - Clean spacing, non-wrapping to prevent jitter */}
+
+
+ ITB
+ £{Math.abs(itb) < 0.05 ? "0.0" : itb.toFixed(1)}m
+
+
+ FT
+
+ {(() => {
+ const chip = chipsByGw[activeGW]; const T = transfersByGw[activeGW]?.count ?? 0;
+ if (chip === "wc") return <>⚡ WC ({T}/∞) ;
+ if (chip === "fh") return <>↩ FH ({T}/∞) ;
+ return `${T} / ${ftAtStartOfGw(activeGW, availableGWs, baselineFt, transfersByGw, chipsByGw)}${hitsThisGw > 0 ? ` (-${hitsThisGw * 4} pts)` : ""}`;
+ })()}
+
+
+
+ Horizon
+ setHorizon(Number(e.target.value))} className="bg-transparent text-sm font-mono font-bold text-luigi-400 outline-none cursor-pointer">
+ {Array.from({ length: maxAvailableHorizon }, (_, i) => i + 1).map((h) => ({h} {h === 1 ? "GW" : "GWs"} ))}
+
+
+
+
+ GW {activeGW} EV
+ {activeGwEV.toFixed(2)}
+
+ {horizonGWs.length > 1 && (
+
+ Horizon EV
+ {horizonEV.toFixed(2)}
+
+ )}
+
+
+ {/* BUTTON ROW - Pushed to the right, strictly locked nowrap */}
+
+
+ {/* 1. RESET TRANSFERS/CHIPS BUTTON (Always Rendered, Disabled if Not Needed) */}
+ {(() => {
+ const canReset = (transfersByGw[activeGW]?.count > 0) || chipsByGw[activeGW] || (manualOverrides[activeGW]?.manualTransfers && Object.keys(manualOverrides[activeGW].manualTransfers).length > 0);
+ return (
+
+
+ );
+ })()}
+
+ {/* 2. RESET LINEUP BUTTON (Always Rendered, Disabled if Not Needed) */}
+ {(() => {
+ let canResetLineup = false;
+ const gwLock = manualOverrides[activeGW];
+
+ if (gwLock?.ids && teamData.length === 15 && !teamData.some((p) => p.isBlank && !String(p.ID).startsWith("blank_"))) {
+ const opt = getValidLayout(teamData, activeGW);
+ if (opt) {
+ const lockStarterSet = new Set(gwLock.ids.slice(0, 11));
+ const optStarterSet = new Set(opt.optimalArray.slice(0, 11).map((p) => p.ID));
+ const differentStarters = lockStarterSet.size !== optStarterSet.size || [...lockStarterSet].some((id) => !optStarterSet.has(id));
+ const meaningfulDiff = differentStarters || gwLock.cap !== opt.cap || gwLock.vice !== opt.vice;
+
+ if (meaningfulDiff) {
+ const getPts = (p) => Number(p[`${activeGW}_Pts`]) || 0;
+ const currentEV = teamData.slice(0, 11).reduce((sum, p) => sum + getPts(p) * (p.ID === gwLock.cap ? 2 : 1), 0);
+ const optEV = opt.optimalArray.slice(0, 11).reduce((sum, p) => sum + getPts(p) * (p.ID === opt.cap ? 2 : 1), 0);
+
+ if (optEV > currentEV + 0.01) {
+ canResetLineup = true;
+ }
+ }
+ }
+ }
+
+ return (
+
+
+ );
+ })()}
+
+ {/* 3. CHIP DROPDOWN */}
+
+ Chip:
+ handleChipSelect(activeGW, e.target.value || null)} className="bg-slate-900 border border-slate-700 rounded px-2 py-1 text-xs font-bold text-slate-300 focus:outline-none cursor-pointer focus:border-luigi-500">
+ None ⚡ WC ↩ FH ⬆ BB ✕3 TC
+
+
+
+
+
+
+ {/* LEFT: Custom Editable Dropdown Box */}
+
+
+ setShowDraftMenu(!showDraftMenu)}
+ className="px-2.5 h-full flex items-center justify-center bg-[#151833] border-l border-[#2a2d5c] hover:bg-[#1e2247] transition-colors"
+ >
+ ▼
+
+
+
+ {showDraftMenu && (
+ <>
+
setShowDraftMenu(false)} />
+
+ {drafts.map(d => (
+ { setActiveDraftId(d.id); setShowDraftMenu(false); }}
+ className={`w-full text-left px-3 py-2 text-[11px] font-bold transition-colors ${d.id === activeDraftId ? "bg-indigo-500/20 text-indigo-300" : "text-slate-400 hover:bg-[#151833] hover:text-slate-200"}`}
+ >
+ {d.name}
+
+ ))}
+
+
+ )}
+
+
+ {/* CENTER: Gameweek Circles */}
+
+ {horizonGWs.map((gw) => (
+ setActiveGW(gw)} className={`relative w-7 h-7 rounded-full flex items-center justify-center text-[11px] font-bold transition-all ${activeGW === gw ? "bg-luigi-500 text-slate-950 scale-110 shadow-[0_0_10px_rgba(16,185,129,0.5)]" : "bg-slate-800 text-slate-400 hover:bg-slate-700 border border-slate-700"}`}>
+ {gw}
+ {chipsByGw[gw] && ({CHIP_CONFIG[chipsByGw[gw]].short[0]} )}
+
+ ))}
+
+
+ {/* RIGHT: Clone / New Draft / Delete */}
+ {/* RIGHT: Clone / New Draft */}
+
+
= 5} className="flex items-center gap-1.5 px-3 py-1.5 bg-indigo-500/10 hover:bg-indigo-500/20 text-indigo-400 border border-indigo-500/20 rounded-lg text-[10px] font-black uppercase tracking-wider transition-all shadow-md active:scale-95 disabled:opacity-50 disabled:cursor-not-allowed" title="Clone reality">
+
+
= 5} className="flex items-center gap-1.5 px-3 py-1.5 bg-emerald-500/10 hover:bg-emerald-500/20 text-emerald-400 border border-emerald-500/20 rounded-lg text-[10px] font-black uppercase tracking-wider transition-all shadow-md active:scale-95 disabled:opacity-50 disabled:cursor-not-allowed" title="New timeline">
+
+
+
+
+
+
+
+ {activeDragPlayer && !activeDragPlayer.isBlank ? (
+
+
+
+ ) : (
+
+ {isLoadingDB || isLoading ? (
+ <>
+
+ {[1, 4, 4, 2].map((count, rowIdx) => (
+
+ {Array.from({ length: count }).map((_, i) => (
+
+ ))}
+
+ ))}
+
+
+
{isLoading ? "Loading squad..." : "Booting Global Engine..."}
+
+ ) : (
+ "Enter your FPL ID above to load your squad."
+ )}
+
+ )}
+
+
+ {/* NEW HOME FOR TABS PANEL */}
+
+
+
+
+
+
+
+
+ {/* MODALS */}
+ {selectedPlayer && !selectedPlayer.isBlank && (
+
+ )}
+ {selectedPlayer && selectedPlayer.isBlank && (
+
+ )}
+ {showAdvancedSettings && (
+
+ )}
+
+ {/* LOADING PORTALS */}
+ {isSolving && createPortal(
+
+
+
+
+
+
+ {/* BRANDED LOGO */}
+
+
+
+
Solving
+
Elapsed {solveElapsedSec}s · up to {quickSettings.iterations} iteration(s)
+
+
abortControllerRef.current?.abort()} className="mt-4 px-6 py-2 rounded-xl bg-slate-900 border border-slate-700 text-slate-400 hover:text-white hover:border-slate-500 font-bold transition-all text-sm">Cancel Solve
+
+
, document.body
+ )}
+
+ {isChipSolving && createPortal(
+
+
+
+
+
+
+ {/* BRANDED LOGO */}
+
+
+
+
Chip Solving
+
Elapsed {chipSolveTimer}s
+
+
+
abortControllerRef.current?.abort()} className="mt-4 px-6 py-2 rounded-xl bg-slate-900 border border-slate-700 text-slate-400 hover:text-white hover:border-slate-500 font-bold transition-all text-sm">Cancel Solve
+
+
, document.body
+ )}
+
+ {isRunningSens && createPortal(
+
+
+
+
+
+
+ {/* BRANDED LOGO */}
+
+
+
+
Sensitivity Analysis
+
Elapsed {sensTimer}s · {numSims} sims running…
+
+
+
abortControllerRef.current?.abort()} className="mt-4 px-6 py-2 rounded-xl bg-slate-900 border border-slate-700 text-slate-400 hover:text-white hover:border-slate-500 font-bold transition-all text-sm">Cancel Solve
+
+
, document.body
+ )}
+
+ {showIdPrompt && (
+
+
+
+
Save as Default ID?
+
+ setShowIdPrompt(false)} className="flex-1 bg-slate-900 text-slate-300 py-2.5 rounded-xl border border-slate-700">Not Now
+ { setUserProfile((prev) => ({ ...prev, defaultTeamId: pendingTeamId })); setShowIdPrompt(false); }} className="flex-1 bg-luigi-500 text-slate-950 py-2.5 rounded-xl font-bold">Save ID
+
+
+
+ )}
+ {/* INITIAL LOGIN ID PROMPT */}
+ {showInitialIdPrompt && (
+
+
+
+
Welcome!
+
Enter your FPL Team ID to set it as your default for future logins.
+
setInitialIdInput(e.target.value)}
+ placeholder="e.g. 123456"
+ className="w-full bg-slate-900 border border-slate-700 rounded-lg py-2.5 px-4 text-sm font-bold text-slate-200 focus:outline-none focus:border-emerald-500 text-center mb-4"
+ />
+
+ setShowInitialIdPrompt(false)} className="flex-1 bg-slate-900 text-slate-400 py-2.5 rounded-xl border border-slate-700 hover:text-slate-300 transition-colors text-sm font-bold">Skip
+ Save Default ID
+
+
+
+ )}
+
+ );
+}
\ No newline at end of file
diff --git a/frontend/src/components/SolverOutputPanel.jsx b/frontend/src/components/SolverOutputPanel.jsx
new file mode 100644
index 0000000000000000000000000000000000000000..7586aff320fa3d2316314779fb1ba45925bcbefc
--- /dev/null
+++ b/frontend/src/components/SolverOutputPanel.jsx
@@ -0,0 +1,201 @@
+import React from "react";
+import { Zap, ExternalLink } from "lucide-react";
+import { CHIP_CONFIG } from "../utils/fplLogic";
+
+export const SolverOutputPanel = ({
+ pendingSolutions, setPendingSolutions, isSolving, globalPlayers, applySolution, appliedPlanSummary, setAppliedPlanSummary, baselineEv = 0
+}) => {
+
+ // BULLETPROOF RELATIVE EV
+ const getRelativeEv = (sol) => {
+ if (baselineEv === undefined || !sol) return "+0.00";
+
+ const base = sol.lockedBaselineEv !== undefined ? sol.lockedBaselineEv : baselineEv;
+
+ if (typeof sol === "number") {
+ const diff = sol - base;
+ return diff >= 0 ? `+${diff.toFixed(2)}` : diff.toFixed(2);
+ }
+
+ if (!sol.plan || !Array.isArray(sol.plan) || sol.plan.length === 0) {
+ const fallbackEv = sol.ev !== undefined ? sol.ev : 0;
+ const diff = fallbackEv - base;
+ return diff >= 0 ? `+${diff.toFixed(2)}` : diff.toFixed(2);
+ }
+
+ let pathEV = 0;
+ let hasValidGw = false;
+
+ sol.plan.forEach(gwPlan => {
+ const gw = gwPlan.gw;
+ if (gw === undefined) return;
+ hasValidGw = true;
+
+ const gwChip = gwPlan.chip;
+ const gwCapMult = gwChip === "tc" ? 3 : 2;
+ let gwPts = 0;
+
+ const getPlayer = (id) => globalPlayers.find(p => String(p.ID) === String(id));
+
+ (gwPlan.lineup || []).forEach(id => {
+ const p = getPlayer(id);
+ if (p && !p.isBlank) {
+ const pts = Number(p[`${gw}_Pts`]) || 0;
+ gwPts += pts * (String(p.ID) === String(gwPlan.captain) ? gwCapMult : 1);
+ }
+ });
+
+ let ofIdx = 0;
+ (gwPlan.bench || []).forEach(id => {
+ const p = getPlayer(id);
+ if (p && !p.isBlank) {
+ const pts = Number(p[`${gw}_Pts`]) || 0;
+ if (gwChip === "bb") {
+ gwPts += pts;
+ } else if (p.Pos === "G") {
+ gwPts += pts * 0.04;
+ } else {
+ gwPts += pts * ([0.17, 0.05, 0.02][ofIdx] || 0.02);
+ ofIdx++;
+ }
+ }
+ });
+ pathEV += gwPts - (gwPlan.hits || 0) * 4;
+ });
+
+ if (!hasValidGw || Number.isNaN(pathEV)) {
+ const fallbackEv = sol.ev !== undefined ? sol.ev : 0;
+ const diff = fallbackEv - base;
+ return diff >= 0 ? `+${diff.toFixed(2)}` : diff.toFixed(2);
+ }
+
+ const diff = pathEV - base;
+ return diff >= 0 ? `+${diff.toFixed(2)}` : diff.toFixed(2);
+ };
+
+ return (
+
+
+
+ {/* Left Side: Original Title & Description */}
+
+
Solver output
+
Nothing changes your squad until you apply a path.
+
+
+ {/* Right Side: Sleek, Minimalist Credit */}
+ {/* Right Side: Sleek, Minimalist Credit */}
+
+ Credit
+ Sertalp-Moose Solver
+
+
+
+
+
+ {pendingSolutions.length > 0 && !isSolving && (
+
+
+
Optimal Paths Found
+ setPendingSolutions([])} className="text-xs text-slate-500 hover:text-red-400 font-bold uppercase transition-colors">Clear
+
+
+ {pendingSolutions.map((sol, index) => (
+
+
+
+ ITERATION {sol.id || index + 1}
+ {sol.chips_used && Object.entries(sol.chips_used).map(([gw, chip]) => {
+ const cfg = CHIP_CONFIG[chip];
+ return cfg ? {cfg.short}{gw} : null;
+ })}
+
+
+ {getRelativeEv(sol)} pts
+ {sol.objective_score != null && eval: {sol.objective_score.toFixed(2)} }
+
+
+
+
+ {sol.plan.map((gwPlan) => (
+ (gwPlan.transfers_in.length > 0 || gwPlan.transfers_out.length > 0) && (
+
+
+
+ GW {gwPlan.gw}
+ {gwPlan.chip && CHIP_CONFIG[gwPlan.chip] && {CHIP_CONFIG[gwPlan.chip].short}{gwPlan.gw} }
+
+
+ ITB: £{Math.abs(gwPlan.itb) < 0.05 ? "0.0" : Number(gwPlan.itb).toFixed(1)}
+ FT Spend: {gwPlan.chip === "wc" || gwPlan.chip === "fh" ? `${gwPlan.transfers_out?.length || 0}/∞` : `${gwPlan.transfers_out?.length || 0}/${gwPlan.ft_at_start ?? 1}${gwPlan.hits > 0 ? ` (-${gwPlan.hits * 4})` : ""}`}
+
+
+ {gwPlan.chip === "wc" || gwPlan.chip === "fh" ?
{gwPlan.chip === "wc" ? "Wildcard active — unlimited free transfers" : "Free Hit active — squad reverts after the FH"}
: null}
+ {gwPlan.transfers_out.map((id, i) => (
+
+ {globalPlayers.find((p) => String(p.ID) === String(id))?.Name || id}
+ »
+ {globalPlayers.find((p) => String(p.ID) === String(gwPlan.transfers_in[i]))?.Name || gwPlan.transfers_in[i]}
+
+ ))}
+
+ )
+ ))}
+
+
applySolution(sol)} className="w-full bg-slate-800 hover:bg-luigi-500 hover:text-slate-950 text-luigi-400 font-bold py-2 rounded-lg transition-colors text-sm">Apply Path
+
+ ))}
+
+ )}
+
+ {!isSolving && pendingSolutions.length === 0 && (
+ appliedPlanSummary ? (
+
+
+
Last Applied · {appliedPlanSummary.horizon}
+ setAppliedPlanSummary(null)} className="text-slate-600 hover:text-red-400 text-xs font-bold">✕
+
+
{getRelativeEv(appliedPlanSummary)} pts {appliedPlanSummary.objectiveScore != null && ` · eval ${appliedPlanSummary.objectiveScore.toFixed(2)}`}
+ {appliedPlanSummary.transfers.map((t, i) => (
+
+
+
+ GW {t.gw}
+ {t.chip && CHIP_CONFIG[t.chip] && {CHIP_CONFIG[t.chip].short}{t.gw} }
+
+
+ FT Spend: {t.chip === "wc" || t.chip === "fh" ? `${t.outs?.length || 0}/∞` : `${t.outs?.length || 0}/${t.ft_at_start ?? 1}${t.hits > 0 ? ` (-${t.hits * 4})` : ""}`}
+ £{Math.abs(t.itb) < 0.05 ? "0.0" : Number(t.itb).toFixed(1)}m
+
+
+ {t.outs.length === 0 && t.ins.length === 0 ? (
+
{t.chip ? `${CHIP_CONFIG[t.chip]?.label || t.chip} active` : 'Hold — no transfers'}
+ ) : (
+ t.outs.map((name, j) => (
+
+ {name}
+ »
+ {t.ins[j] || "?"}
+
+ ))
+ )}
+
+ ))}
+
+ ) : (
+
+ Solve in the left panel.
+
+ )
+ )}
+
+
+ );
+};
\ No newline at end of file
diff --git a/frontend/src/components/SquadEvDisplay.jsx b/frontend/src/components/SquadEvDisplay.jsx
new file mode 100644
index 0000000000000000000000000000000000000000..d7ce8d0b82e75ab2e64eda9bdf6f25cf5ee96477
--- /dev/null
+++ b/frontend/src/components/SquadEvDisplay.jsx
@@ -0,0 +1,16 @@
+import React from "react";
+
+export const SquadEvDisplay = ({ activeGW, activeGwEV, horizonGWs, horizonEV }) => {
+ return (
+ <>
+
+ GW {activeGW} EV: {activeGwEV.toFixed(2)}
+
+ {horizonGWs?.length > 1 && (
+
+ GW {horizonGWs[0]}-{horizonGWs[horizonGWs.length - 1]} EV: {horizonEV.toFixed(2)}
+
+ )}
+
+ );
+};
\ No newline at end of file
diff --git a/frontend/src/components/TabsPanel.jsx b/frontend/src/components/TabsPanel.jsx
new file mode 100644
index 0000000000000000000000000000000000000000..ac71da89c74ecbe61985e5cfada2741ee800410b
--- /dev/null
+++ b/frontend/src/components/TabsPanel.jsx
@@ -0,0 +1,347 @@
+import React, { useContext } from "react";
+import { Settings } from "lucide-react";
+import { CHIP_CONFIG } from "../utils/fplLogic";
+import { PlayerContext } from "../PlayerContext";
+import { FixtureMatrixPanel } from "./FixtureMatrixPanel";
+
+export const TabsPanel = ({
+ solverTab, setSolverTab,
+ isSolving, isRunningSens, isChipSolving,
+ runMainSolver, runSensAnalysis, runChipSolve,
+ setShowAdvancedSettings,
+ quickSettings, setQuickSettings,
+ banSearch, setBanSearch, lockSearch, setLockSearch,
+ globalPlayers, teamData, solveGWLabel,
+ numSims, setNumSims, sensResults, setSensResults, sensViewGw, setSensViewGw,
+ chipSolveOptions, setChipSolveOptions, chipSolveSolutions, setChipSolveSolutions, horizonGWs,baselineEv = 0
+}) => {
+
+ const { fixtureOverrides, setFixtureOverrides, availableGWs } = useContext(PlayerContext);
+
+ const cleanString = (str) => str ? str.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase() : "";
+
+ const getRelativeEv = (sol) => {
+ if (baselineEv === undefined || !sol) return "+0.00";
+
+ // Prevent 0.0 bug: Use locked baseline if it's the "Last Applied" summary
+ const base = sol.lockedBaselineEv !== undefined ? sol.lockedBaselineEv : baselineEv;
+
+ // Prevent NaN bug: Safely handle if sol is just a raw number by accident
+ if (typeof sol === "number") {
+ const diff = sol - base;
+ return diff >= 0 ? `+${diff.toFixed(2)}` : diff.toFixed(2);
+ }
+
+ // Prevent NaN bug: If the API didn't return a full detailed plan (like in Chip Solve)
+ if (!sol.plan || !Array.isArray(sol.plan) || sol.plan.length === 0) {
+ const fallbackEv = sol.ev !== undefined ? sol.ev : 0;
+ const diff = fallbackEv - base;
+ return diff >= 0 ? `+${diff.toFixed(2)}` : diff.toFixed(2);
+ }
+
+ let pathEV = 0;
+ let hasValidGw = false;
+
+ sol.plan.forEach(gwPlan => {
+ const gw = gwPlan.gw;
+ if (gw === undefined) return; // Prevents checking p['undefined_Pts']
+ hasValidGw = true;
+
+ const gwChip = gwPlan.chip;
+ const gwCapMult = gwChip === "tc" ? 3 : 2;
+ let gwPts = 0;
+
+ const getPlayer = (id) => globalPlayers.find(p => String(p.ID) === String(id));
+
+ (gwPlan.lineup || []).forEach(id => {
+ const p = getPlayer(id);
+ if (p && !p.isBlank) {
+ const pts = Number(p[`${gw}_Pts`]) || 0;
+ gwPts += pts * (String(p.ID) === String(gwPlan.captain) ? gwCapMult : 1);
+ }
+ });
+
+ let ofIdx = 0;
+ (gwPlan.bench || []).forEach(id => {
+ const p = getPlayer(id);
+ if (p && !p.isBlank) {
+ const pts = Number(p[`${gw}_Pts`]) || 0;
+ if (gwChip === "bb") {
+ gwPts += pts;
+ } else if (p.Pos === "G") {
+ gwPts += pts * 0.04;
+ } else {
+ gwPts += pts * ([0.17, 0.05, 0.02][ofIdx] || 0.02);
+ ofIdx++;
+ }
+ }
+ });
+ pathEV += gwPts - (gwPlan.hits || 0) * 4;
+ });
+
+ // Failsafe in case the plan existed but couldn't be parsed properly
+ if (!hasValidGw || Number.isNaN(pathEV)) {
+ const fallbackEv = sol.ev !== undefined ? sol.ev : 0;
+ const diff = fallbackEv - base;
+ return diff >= 0 ? `+${diff.toFixed(2)}` : diff.toFixed(2);
+ }
+
+ const diff = pathEV - base;
+ return diff >= 0 ? `+${diff.toFixed(2)}` : diff.toFixed(2);
+ };
+
+ return (
+ <>
+
setShowAdvancedSettings(true)} className="absolute top-3 right-3 text-slate-500 hover:text-luigi-400 transition-colors z-10" aria-label="Comprehensive settings">
+
+ {["solver", "sensitivity", "chips","fixtures"].map((tab) => (
+ setSolverTab(tab)} className={`flex-1 py-4 text-xs font-black uppercase tracking-widest transition-colors ${solverTab === tab ? "text-luigi-400 border-b-2 border-luigi-400" : "text-slate-500 hover:text-slate-300"}`}>
+ {tab === "solver" ? "Solve" : tab === "sensitivity" ? "Sens Anal" : tab === "chips" ? "Chips" : "Fixtures"}
+
+ ))}
+
+
+
+ {solverTab === "solver" && (
+
+
Quick Settings
+
+ {/* TOOLBAR LAYOUT: Readable sizes, allowed to wrap if screen is small */}
+
+
+ {/* Decay */}
+
+ Decay
+
+
+ {/* FT Val */}
+
+ FT Val
+
+
+ {/* Iters */}
+
+ Iters
+ setQuickSettings({...quickSettings, iterations: Number(e.target.value)})} className="w-full bg-slate-900 border border-slate-700 rounded px-2 py-1.5 text-slate-200 font-mono text-xs outline-none focus:border-luigi-500 cursor-pointer">
+ {[1, 2, 3, 4, 5].map(i => {i} )}
+
+
+
+ {/* Lock */}
+
+
Lock
+
setLockSearch(e.target.value)} className="w-full bg-slate-900 border border-slate-700 rounded px-2 py-1.5 text-xs text-emerald-400 focus:outline-none focus:border-emerald-500" />
+ {lockSearch && (
+
+ {/* THE FIX: Added (quickSettings.locked || []) */}
+ {globalPlayers.filter((p) => cleanString(p.Name).includes(cleanString(lockSearch)) && !(quickSettings.locked || []).some((l) => l.ID === p.ID)).slice(0, 10).map((p) => (
+
{ setQuickSettings((prev) => ({ ...prev, locked: [...(prev.locked || []), p] })); setLockSearch(""); }} className="px-2 py-1.5 text-xs text-slate-300 hover:bg-slate-700 cursor-pointer border-b border-slate-700/50 truncate">
+ {p.Name} ({p.Team})
+
+ ))}
+
+ )}
+
+ {/* THE FIX: Added (quickSettings.locked || []) */}
+ {(quickSettings.locked || []).map((p) => (
+
+ {p.Name} setQuickSettings((prev) => ({ ...prev, locked: (prev.locked || []).filter((l) => l.ID !== p.ID) })) } className="hover:text-white shrink-0">✕
+
+ ))}
+
+
+
+ {/* Ban */}
+
+
Ban
+
setBanSearch(e.target.value)} className="w-full bg-slate-900 border border-slate-700 rounded px-2 py-1.5 text-xs text-red-400 focus:outline-none focus:border-red-500" />
+ {banSearch && (
+
+ {/* THE FIX: Added (quickSettings.banned || []) */}
+ {globalPlayers.filter((p) => cleanString(p.Name).includes(cleanString(banSearch)) && !(quickSettings.banned || []).some((b) => b.ID === p.ID)).slice(0, 10).map((p) => (
+
{ setQuickSettings((prev) => ({ ...prev, banned: [...(prev.banned || []), p] })); setBanSearch(""); }} className="px-2 py-1.5 text-xs text-slate-300 hover:bg-slate-700 cursor-pointer border-b border-slate-700/50 truncate">
+ {p.Name} ({p.Team})
+
+ ))}
+
+ )}
+
+ {/* THE FIX: Added (quickSettings.banned || []) */}
+ {(quickSettings.banned || []).map((p) => (
+
+ {p.Name} setQuickSettings((prev) => ({ ...prev, banned: (prev.banned || []).filter((b) => b.ID !== p.ID) })) } className="hover:text-white shrink-0">✕
+
+ ))}
+
+
+
+
+
+
p.isBlank) || teamData.length === 0 || isSolving } className="mt-auto self-center bg-luigi-500 hover:bg-luigi-400 text-slate-950 font-black px-10 py-2.5 rounded-lg shadow-lg transition-all active:scale-95 text-xs uppercase tracking-widest disabled:opacity-50 disabled:cursor-not-allowed disabled:shadow-none">
+ Solve {solveGWLabel ? `(${solveGWLabel})` : ""}
+
+
+ )}
+
+ {solverTab === "sensitivity" && (
+
+
+ Runs N randomised solves with per-player EV noise.
+
+
+ Simulations
+
+
p.isBlank) || teamData.length === 0 } className="self-center bg-cyan-700 hover:bg-cyan-600 text-white font-black px-10 py-2.5 rounded-lg shadow-lg transition-all active:scale-95 text-sm uppercase tracking-widest disabled:opacity-50 disabled:cursor-not-allowed">
+ {isRunningSens ? `Running...` : `Run Sims ${solveGWLabel ? `(${solveGWLabel})` : ""}`}
+
+ {sensResults && (
+
+
+
{sensResults.valid_runs}/{sensResults.num_sims} valid
+ { setSensResults(null); setSensViewGw(null); }} className="text-xs text-slate-500 hover:text-red-400 font-bold uppercase">Clear
+
+
+ {(sensResults.horizon_gws || []).map((gw) => {
+ const isChipFree = sensResults.gw_results?.[String(gw)]?.is_chip_free;
+ const isActive = sensViewGw === gw;
+ return (
+ setSensViewGw(gw)} className={`w-8 h-8 rounded-full text-[11px] font-black transition-colors ${isActive ? isChipFree ? "bg-purple-500 text-white" : "bg-cyan-500 text-slate-950" : isChipFree ? "bg-purple-900/60 text-purple-300 hover:bg-purple-800/60 ring-1 ring-purple-500/40" : "bg-slate-800 text-slate-400 hover:bg-slate-700"}`}>{gw}
+ );
+ })}
+
+ {sensViewGw && sensResults.gw_results?.[String(sensViewGw)] && (() => {
+ const gd = sensResults.gw_results[String(sensViewGw)];
+ if (gd.is_chip_free) {
+ const POS_NAMES = { G: "Goalkeepers", D: "Defenders", M: "Midfielders", F: "Forwards" };
+ return (
+
+
⚡ Wildcard / Free Hit — Squad Selection
+ {["G", "D", "M", "F"].map((pos) => {
+ const rows = gd.players?.[pos] || [];
+ if (!rows.length) return null;
+ return (
+
+
{POS_NAMES[pos]}
+
Player Squad Lineup
+ {rows.map((r, i) => (
+
+
+
{r.squad_pct}% {r.lineup_pct}%
+
+ ))}
+
+ );
+ })}
+
+ );
+ }
+ return (
+
+ {gd.no_transfer_pct > 0 &&
Hold (no transfer): {gd.no_transfer_pct}% of sims
}
+ {["moves", "buys", "sells"].map((key) => {
+ const rows = gd[key] || [];
+ if (!rows.length) return null;
+ const titles = { moves: "Moves (Out → In)", buys: "Buys", sells: "Sells" };
+ return (
+
+
{titles[key]}
+ {rows.slice(0, 10).map((r, i) => (
+
+ ))}
+
+ );
+ })}
+
+ );
+ })()}
+
+ )}
+
+ )}
+
+ {solverTab === "chips" && (
+
+
+ Select which GWs each chip can be played in, then hit Chip Solve .
+
+
+ {["wc", "fh", "bb", "tc"].map((key) => {
+ const cfg = CHIP_CONFIG[key];
+ const sel = chipSolveOptions[key] || [];
+ return (
+
+
+ {cfg.label}
+ {sel.length > 0 && {sel.length} GW{sel.length > 1 ? "s" : ""} }
+
+
+ {horizonGWs.map((gw) => {
+ const active = sel.includes(gw);
+ return (
+ setChipSolveOptions((prev) => ({ ...prev, [key]: active ? prev[key].filter((g) => g !== gw) : [...prev[key], gw] })) } className={`text-[10px] px-1.5 py-0.5 rounded font-bold transition-colors ${active ? cfg.activeBg : cfg.inactiveBg}`}>{gw}
+ );
+ })}
+
+
+ );
+ })}
+
+
p.isBlank) || teamData.length === 0 || Object.values(chipSolveOptions).every((v) => v.length === 0) } className="self-center mt-2 bg-purple-600 hover:bg-purple-500 text-white font-black px-10 py-2.5 rounded-lg shadow-lg transition-all active:scale-95 text-sm uppercase tracking-widest disabled:opacity-50 disabled:cursor-not-allowed">
+ {isChipSolving ? `Solving...` : "Chip Solve"}
+
+ {chipSolveSolutions.length > 0 && (
+
+
+
Best Chip Combos
+ setChipSolveSolutions([])} className="text-xs text-slate-500 hover:text-red-400 font-bold uppercase">Clear
+
+ {chipSolveSolutions.slice(0, 8).map((sol, i) => {
+ const combo = sol.chip_combo || {};
+
+ const active = Object.entries(combo)
+ .filter(([, gws]) => Array.isArray(gws) && gws.length > 0)
+ .map(([k, gws]) => `${k.replace("use_", "").toUpperCase()}${gws[0]}`);
+
+ return (
+
+
+ {/* 1. Added Rank Number (1., 2., 3...) */}
+ {i + 1}.
+ {active.length ? active.join(" + ") : "No chips"}
+
+
+
+
+ {sol.objective_score != null ? sol.objective_score.toFixed(2) : sol.ev.toFixed(2)}
+
+ {/* 2. EV is now bigger (text-[10px]) and colored purple to match! */}
+
+ ({getRelativeEv(sol)} ev)
+
+
+
+ );
+ })}
+
+ )}
+
+ )}
+
+ {solverTab === "fixtures" && (
+
+ )}
+
+
+ );
+};
\ No newline at end of file
diff --git a/frontend/src/components/TeamRatings.jsx b/frontend/src/components/TeamRatings.jsx
new file mode 100644
index 0000000000000000000000000000000000000000..2881f907bd3ebaf10bd36e7d130799aa0649c3cf
--- /dev/null
+++ b/frontend/src/components/TeamRatings.jsx
@@ -0,0 +1,130 @@
+import React, { useState, useEffect } from 'react';
+
+export default function TeamRatings() {
+ const [data, setData] = useState([]);
+ const [isLoading, setIsLoading] = useState(true);
+
+ useEffect(() => {
+ fetch('https://anayshukla-fpl-solver.hf.space/api/ratings')
+ .then(res => res.json())
+ .then(jsonData => {
+ setData(jsonData.sort((a, b) => b.Diff - a.Diff));
+ setIsLoading(false);
+ });
+ }, []);
+
+ if (isLoading) return
Loading ratings...
;
+
+ const minAttack = 0.6, maxAttack = 2.2;
+ const minDef = 0.6, maxDef = 2.0;
+
+ const yTicks = [0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2];
+ const xTicks = [2.0, 1.8, 1.6, 1.4, 1.2, 1.0, 0.8, 0.6];
+
+ return (
+
+
+ {/* WIDESCREEN SCATTER PLOT */}
+
+
Team Strengths
+
+
+
+ {/* THE FIX: Added ml-16 and mb-16 to give the absolute-positioned numbers room to breathe without being clipped! */}
+
+
+ {/* Y-Axis Label (Attack) - Swapped to ➡️ so the -90deg rotation makes it point UP */}
+
+ Attack (Better ➡️)
+
+
+ {/* X-Axis Label (Defence) - Now perfectly aligned */}
+
+ Defence (Better ➡️)
+
+
+ {/* Y-Axis Ticks */}
+ {yTicks.map(tick => {
+ const bottomPct = ((tick - minAttack) / (maxAttack - minAttack)) * 100;
+ return (
+
+
+
+ {tick.toFixed(1)}
+
+
+ );
+ })}
+
+ {/* X-Axis Ticks */}
+ {xTicks.map(tick => {
+ const leftPct = ((maxDef - tick) / (maxDef - minDef)) * 100;
+ return (
+
+
+
+ {tick.toFixed(1)}
+
+
+ );
+ })}
+
+ {/* Plotting the Teams */}
+ {data.map(team => {
+ const leftPct = ((maxDef - team.Defence) / (maxDef - minDef)) * 100;
+ const bottomPct = ((team.Attack - minAttack) / (maxAttack - minAttack)) * 100;
+
+ return (
+
+ {team.Logo ? (
+
+ ) : (
+
+ )}
+
+
+
{team.Team}
+
Attack: {team.Attack.toFixed(2)}
+
Defence: {team.Defence.toFixed(2)}
+
+
+ );
+ })}
+
+
+
+
+ {/* FULL WIDTH DATA TABLE */}
+
+
+
+
+ Team
+ Attack
+ Defence
+ Diff
+
+
+
+ {data.map(team => (
+
+ {team.Team}
+ {team.Attack.toFixed(2)}
+ {team.Defence.toFixed(2)}
+
+ 0 ? 'text-emerald-400' : 'text-red-400'}>
+ {team.Diff > 0 ? '+' : ''}{team.Diff.toFixed(2)}
+
+
+
+ ))}
+
+
+
+
+ );
+}
\ No newline at end of file
diff --git a/frontend/src/hooks/useFplSolverApi.js b/frontend/src/hooks/useFplSolverApi.js
new file mode 100644
index 0000000000000000000000000000000000000000..62dad1ec45e8caf4c1c23e78531ede4a74f25e8b
--- /dev/null
+++ b/frontend/src/hooks/useFplSolverApi.js
@@ -0,0 +1,272 @@
+import { useState } from "react";
+import { getPlayerPrice } from "../utils/fplLogic";
+
+export const useFplSolverApi = (abortControllerRef) => {
+ const [isSolving, setIsSolving] = useState(false);
+ const [isChipSolving, setIsChipSolving] = useState(false);
+ const [isRunningSens, setIsRunningSens] = useState(false);
+ const [pendingSolutions, setPendingSolutions] = useState([]);
+ const [chipSolveSolutions, setChipSolveSolutions] = useState([]);
+ const [sensResults, setSensResults] = useState(null);
+ const [sensViewGw, setSensViewGw] = useState(null);
+
+ // Reusable helper to format players for the backend
+ const formatMarketPlayers = (globalPlayers, teamData, horizonGWs) => {
+ return globalPlayers.map((p) => {
+ const squadPlayer = teamData.find((sp) => sp.ID === p.ID);
+ const sellPrice = squadPlayer ? squadPlayer.Price : getPlayerPrice(p);
+ const evs = {};
+ horizonGWs.forEach((gw) => {
+ evs[String(gw)] = Number(p[`${gw}_Pts`]) || 0;
+ });
+ return {
+ id: p.ID,
+ name: p.Name,
+ pos: p.Pos,
+ team: p.Team,
+ now_cost: getPlayerPrice(p),
+ sell_price: sellPrice,
+ evs,
+ };
+ });
+ };
+
+ // Extracts the basic frontend settings (bans, locks, chips) into a clean dictionary
+ const buildBaseSettings = (quickSettings, chipsByGw, forceIterations = null) => {
+ return {
+ decay_base: Number(quickSettings?.decay || 0.85),
+ ft_value_base: Number(quickSettings?.ft_value || 1.5),
+ iterations: forceIterations !== null ? forceIterations : Number(quickSettings?.iterations || 1),
+ banned_ids: quickSettings?.banned?.map((p) => p.ID) || [],
+ locked_ids: quickSettings?.locked?.map((p) => p.ID) || [],
+ use_wc: Object.entries(chipsByGw || {}).filter(([, c]) => c === "wc").map(([g]) => Number(g)),
+ use_fh: Object.entries(chipsByGw || {}).filter(([, c]) => c === "fh").map(([g]) => Number(g)),
+ use_bb: Object.entries(chipsByGw || {}).filter(([, c]) => c === "bb").map(([g]) => Number(g)),
+ use_tc: Object.entries(chipsByGw || {}).filter(([, c]) => c === "tc").map(([g]) => Number(g)),
+ };
+ };
+
+ const handleSolve = async ({
+ teamId, solveGWs, horizonGWs, teamData, globalPlayers, itb, availableFts,
+ quickSettings, chipsByGw, comprehensiveSettings,
+ lockedBaselineEv, pastBaselineEv // <-- ADDED HERE
+ }) => {
+ setIsSolving(true);
+ abortControllerRef.current = new AbortController();
+ try {
+ const payload = {
+ team_id: parseInt(teamId, 10) || 0,
+ horizon_gws: solveGWs,
+ current_squad_ids: teamData.filter((p) => !p.isBlank && typeof p.ID === "number").map((p) => p.ID),
+ market_players: formatMarketPlayers(globalPlayers, teamData, horizonGWs),
+ in_the_bank: itb,
+ free_transfers: availableFts,
+ settings: buildBaseSettings(quickSettings, chipsByGw),
+ comprehensive_settings: comprehensiveSettings,
+ };
+
+ const res = await fetch("https://anayshukla-fpl-solver.hf.space/api/solve", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(payload),
+ signal: abortControllerRef.current.signal,
+ });
+
+ const data = await res.json();
+ if (!res.ok) throw new Error(data.detail || data.message || "Solver failed");
+
+ if (data.status === "success" && Array.isArray(data.solutions)) {
+ // THE FIX: Inject the specific baselines and calculate the padded visual total
+ const enhancedSolutions = data.solutions.map(sol => ({
+ ...sol,
+ lockedBaselineEv,
+ paddedTotalEv: (sol.ev || 0) + (pastBaselineEv || 0)
+ }));
+
+ const sorted = [...enhancedSolutions].sort((a, b) => {
+ const oa = a.objective_score != null ? a.objective_score : a.ev;
+ const ob = b.objective_score != null ? b.objective_score : b.ev;
+ if (ob !== oa) return ob - oa;
+ return (b.ev || 0) - (a.ev || 0);
+ });
+ setPendingSolutions(sorted);
+ } else {
+ alert("Solver failed: " + (data.message || data.detail || "Unknown"));
+ }
+ } catch (err) {
+ if (err.name === 'AbortError') return;
+ alert(err.message || "Failed to run the solver.");
+ } finally {
+ setIsSolving(false);
+ }
+ };
+
+ const handleChipSolve = async ({
+ teamId, horizonGWs, teamData, globalPlayers, itb, availableFts,
+ quickSettings, comprehensiveSettings, chipSolveOptions,
+ lockedBaselineEv, pastBaselineEv // <-- ADDED HERE
+ }) => {
+ const hasOptions = Object.values(chipSolveOptions).some((v) => v.length > 0);
+ if (!hasOptions) {
+ alert("Select at least one GW for a chip before running the chip solve.");
+ return;
+ }
+
+ setIsChipSolving(true);
+ setChipSolveSolutions([]);
+ abortControllerRef.current = new AbortController();
+
+ try {
+ const payload = {
+ team_id: parseInt(teamId, 10) || 0,
+ horizon_gws: horizonGWs,
+ current_squad_ids: teamData.filter((p) => !p.isBlank && typeof p.ID === "number").map((p) => p.ID),
+ market_players: formatMarketPlayers(globalPlayers, teamData, horizonGWs),
+ in_the_bank: itb,
+ free_transfers: availableFts,
+ settings: buildBaseSettings(quickSettings, {}),
+ comprehensive_settings: comprehensiveSettings,
+ chip_gw_options: {
+ wc: chipSolveOptions.wc,
+ fh: chipSolveOptions.fh,
+ bb: chipSolveOptions.bb,
+ tc: chipSolveOptions.tc,
+ },
+ };
+
+ const res = await fetch("https://anayshukla-fpl-solver.hf.space/api/chip-solve", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(payload),
+ signal: abortControllerRef.current.signal,
+ });
+
+ const data = await res.json();
+ if (!res.ok) {
+ const d = data.detail;
+ const msg = typeof d === "string" ? d : Array.isArray(d) ? d.map((x) => x.msg || x).join(", ") : JSON.stringify(d);
+ throw new Error(msg || "Chip solve failed");
+ }
+
+ if (data.status === "success" && Array.isArray(data.solutions)) {
+ // THE FIX: Inject the specific baselines
+ const enhancedSolutions = data.solutions.map(sol => ({
+ ...sol,
+ lockedBaselineEv,
+ paddedTotalEv: (sol.ev || 0) + (pastBaselineEv || 0)
+ }));
+ setChipSolveSolutions(enhancedSolutions);
+ } else {
+ alert("Chip solve failed: " + (data.message || "Unknown error"));
+ }
+ } catch (err) {
+ if (err.name === 'AbortError') return;
+ alert(err.message || "Failed to run chip solve.");
+ } finally {
+ setIsChipSolving(false);
+ }
+ };
+
+ const handleSensAnalysis = async ({
+ teamId, solveGWs, horizonGWs, teamData, globalPlayers, itb, availableFts,
+ quickSettings, chipsByGw, comprehensiveSettings, numSims, lockedBaselineEv, pastBaselineEv
+ }) => {
+ setIsRunningSens(true);
+ setSensResults(null);
+ abortControllerRef.current = new AbortController();
+
+ try {
+ const payload = {
+ team_id: parseInt(teamId, 10) || 0,
+ horizon_gws: solveGWs,
+ current_squad_ids: teamData.filter((p) => !p.isBlank && typeof p.ID === "number").map((p) => p.ID),
+ market_players: formatMarketPlayers(globalPlayers, teamData, horizonGWs),
+ in_the_bank: itb,
+ free_transfers: availableFts,
+ settings: buildBaseSettings(quickSettings, chipsByGw, 1), // Force 1 iteration for sens analysis
+ comprehensive_settings: comprehensiveSettings,
+ num_sims: numSims,
+ analysis_gw: solveGWs[0] || null,
+ };
+
+ const res = await fetch("https://anayshukla-fpl-solver.hf.space/api/sensitivity", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(payload),
+ signal: abortControllerRef.current.signal,
+ });
+
+ const data = await res.json();
+ if (!res.ok) {
+ const d = data.detail;
+ const msg = typeof d === "string" ? d : Array.isArray(d) ? d.map((x) => x.msg || x).join(", ") : JSON.stringify(d);
+ throw new Error(msg || "Sensitivity analysis failed");
+ }
+
+ if (data.status === "success") {
+ setSensResults(data);
+ setSensViewGw(data.horizon_gws?.[0] ?? null);
+ } else {
+ alert("Sensitivity failed: " + (data.message || "Unknown error"));
+ }
+ } catch (err) {
+ if (err.name === 'AbortError') return;
+ alert(err.message || "Failed to run sensitivity analysis.");
+ } finally {
+ setIsRunningSens(false);
+ }
+ };
+
+ const loadSettingsFromCloud = async (teamId) => {
+ try {
+ const res = await fetch(`https://anayshukla-fpl-solver.hf.space/api/settings/${teamId}`);
+ const data = await res.json();
+ if (data.status === "success") {
+ console.log("📥 LOADED FROM CLOUD:", data);
+ return {
+ quick: data.quick_settings,
+ advanced: data.advanced_settings
+ };
+ }
+ } catch (err) {
+ console.warn("Failed to load cloud settings:", err);
+ }
+ return null;
+ };
+
+ const saveSettingsToCloud = async (teamId, quickSettings, compSettings) => {
+ console.log("📤 SAVING TO CLOUD. Advanced Settings payload:", compSettings);
+ try {
+ await fetch("https://anayshukla-fpl-solver.hf.space/api/settings/save", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ team_id: parseInt(teamId, 10),
+ quick_settings: quickSettings,
+ advanced_settings: compSettings // <-- Safely maps React state to Python expectation
+ })
+ });
+ } catch (err) {
+ console.warn("Failed to save settings to cloud:", err);
+ }
+ };
+
+ return {
+ isSolving,
+ isChipSolving,
+ isRunningSens,
+ pendingSolutions,
+ setPendingSolutions,
+ chipSolveSolutions,
+ setChipSolveSolutions,
+ sensResults,
+ setSensResults,
+ sensViewGw,
+ setSensViewGw,
+ handleSolve,
+ handleChipSolve,
+ handleSensAnalysis,
+ loadSettingsFromCloud,
+ saveSettingsToCloud,
+ };
+};
\ No newline at end of file
diff --git a/frontend/src/index.css b/frontend/src/index.css
new file mode 100644
index 0000000000000000000000000000000000000000..3c1bde3519b94ae1d6a3a894837c9640aa870cd0
--- /dev/null
+++ b/frontend/src/index.css
@@ -0,0 +1,61 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@keyframes solve-indeterminate {
+ 0% {
+ transform: translateX(-100%);
+ }
+
+ 100% {
+ transform: translateX(400%);
+ }
+}
+
+@keyframes transfer-glow {
+
+ 0%,
+ 100% {
+ box-shadow:
+ 0 0 16px rgba(34, 211, 238, 0.35),
+ 0 0 36px rgba(16, 185, 129, 0.2),
+ inset 0 0 14px rgba(6, 182, 212, 0.12);
+ }
+
+ 50% {
+ box-shadow:
+ 0 0 28px rgba(34, 211, 238, 0.55),
+ 0 0 52px rgba(139, 92, 246, 0.18),
+ inset 0 0 22px rgba(16, 185, 129, 0.18);
+ }
+}
+
+.transfer-highlight-card {
+ animation: transfer-glow 2.4s ease-in-out infinite;
+ border-radius: 0.75rem;
+}
+
+/* ─── Global Smoothness ─── */
+html {
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+}
+* { -webkit-tap-highlight-color: transparent; }
+
+/* Tabular nums: all digits same width → no layout shift on number changes */
+.tabular-nums { font-variant-numeric: tabular-nums; }
+
+/* Skeleton loading pulse */
+@keyframes skeleton-pulse {
+ 0%, 100% { opacity: 0.12; }
+ 50% { opacity: 0.28; }
+}
+.skeleton-pulse {
+ animation: skeleton-pulse 1.8s ease-in-out infinite;
+}
+
+/* Slim themed scrollbar */
+.custom-scrollbar::-webkit-scrollbar { width: 5px; }
+.custom-scrollbar::-webkit-scrollbar-track { background: transparent; }
+.custom-scrollbar::-webkit-scrollbar-thumb { background: rgba(100,116,139,0.25); border-radius: 999px; }
+.custom-scrollbar::-webkit-scrollbar-thumb:hover { background: rgba(100,116,139,0.45); }
\ No newline at end of file
diff --git a/frontend/src/main.jsx b/frontend/src/main.jsx
new file mode 100644
index 0000000000000000000000000000000000000000..c2f8953aa1d8d4edf396389228c0f032b383c14e
--- /dev/null
+++ b/frontend/src/main.jsx
@@ -0,0 +1,14 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App.jsx';
+import './index.css';
+import { GoogleOAuthProvider } from '@react-oauth/google'; // <-- ADD THIS
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+
+ {/* REPLACE WITH YOUR ACTUAL CLIENT ID */}
+
+
+ ,
+)
\ No newline at end of file
diff --git a/frontend/src/utils/fplLogic.js b/frontend/src/utils/fplLogic.js
new file mode 100644
index 0000000000000000000000000000000000000000..92716e66885b7fc6414ff2a5951a1f3509c08e5d
--- /dev/null
+++ b/frontend/src/utils/fplLogic.js
@@ -0,0 +1,130 @@
+// src/utils/fplLogic.js
+
+export const CHIP_CONFIG = {
+ wc: {
+ label: "Wildcard", short: "WC", desc: "Unlimited free transfers for 1 GW. FTs reset to max after.",
+ dot: "bg-yellow-400", text: "text-yellow-400", activeBg: "bg-yellow-500 text-slate-950",
+ inactiveBg: "bg-slate-800 text-slate-500 hover:bg-slate-700", border: "border-yellow-700/40", badge: "bg-yellow-500/20 text-yellow-300",
+ },
+ fh: {
+ label: "Free Hit", short: "FH", desc: "Unlimited transfers for 1 GW. Squad reverts to original after.",
+ dot: "bg-orange-400", text: "text-orange-400", activeBg: "bg-orange-500 text-slate-950",
+ inactiveBg: "bg-slate-800 text-slate-500 hover:bg-slate-700", border: "border-orange-700/40", badge: "bg-orange-500/20 text-orange-300",
+ },
+ bb: {
+ label: "Bench Boost", short: "BB", desc: "All 15 squad players score points this GW.",
+ dot: "bg-emerald-400", text: "text-emerald-400", activeBg: "bg-emerald-500 text-slate-950",
+ inactiveBg: "bg-slate-800 text-slate-500 hover:bg-slate-700", border: "border-emerald-700/40", badge: "bg-emerald-500/20 text-emerald-300",
+ },
+ tc: {
+ label: "Triple Captain", short: "TC", desc: "Captain earns 3× points instead of 2× this GW.",
+ dot: "bg-purple-400", text: "text-purple-400", activeBg: "bg-purple-500 text-white",
+ inactiveBg: "bg-slate-800 text-slate-500 hover:bg-slate-700", border: "border-purple-700/40", badge: "bg-purple-500/20 text-purple-300",
+ },
+};
+
+export const getPlayerPrice = (p) => {
+ // 1. Exact FPL Calculation if we have both purchase_price and now_cost
+ let pp = p.purchase_price !== undefined ? Number(p.purchase_price) : undefined;
+ let nc = p.now_cost !== undefined ? Number(p.now_cost) : undefined;
+
+ // FPL API sometimes sends prices multiplied by 10 (e.g., 43 for 4.3m)
+ if (pp > 20) pp = pp / 10;
+ if (nc > 20) nc = nc / 10;
+
+ if (pp !== undefined && nc !== undefined) {
+ if (nc > pp) {
+ // Gain is 0.1m for every 0.2m increase.
+ // To avoid floating point errors, multiply by 10, floor the difference/2, and divide by 10.
+ const diff = Math.round((nc - pp) * 10);
+ const gain = Math.floor(diff / 2);
+ return (Math.round(pp * 10) + gain) / 10;
+ } else {
+ // FPL Rule: You take full losses on price drops.
+ return nc;
+ }
+ }
+
+ // 2. Fallbacks if purchase_price isn't explicitly available
+ if (p.selling_price !== undefined && p.selling_price !== null) {
+ const sp = Number(p.selling_price);
+ return sp > 20 ? sp / 10 : sp;
+ }
+ if (p.sell_price !== undefined && p.sell_price !== null) {
+ const sp = Number(p.sell_price);
+ return sp > 20 ? sp / 10 : sp;
+ }
+ if (p.Price !== undefined) return Number(p.Price);
+ if (nc !== undefined) return nc;
+
+ return 0;
+};
+
+export function normalizeBenchGkFirst(teamData, gw) {
+ if (!teamData.length || teamData.length < 15 || !gw) return teamData;
+ const starters = teamData.slice(0, 11);
+ const bench = teamData.slice(11, 15);
+ const getEV = (p) => Number(p[`${gw}_Pts`]) || 0;
+ const nonBlank = bench.filter((p) => !p.isBlank);
+ const blanks = bench.filter((p) => p.isBlank);
+ const gk = nonBlank.find((p) => p.Pos === "G");
+ const outfield = nonBlank.filter((p) => p.Pos !== "G");
+ outfield.sort((a, b) => getEV(b) - getEV(a));
+ const ordered = gk ? [gk, ...outfield] : [...outfield];
+ const newBench = [...ordered, ...blanks];
+ while (newBench.length < 4) {
+ newBench.push({
+ ID: `blank_pad_${Date.now()}_${newBench.length}`,
+ isBlank: true, Pos: "M", Name: "", Team: "", Price: 0,
+ });
+ }
+ return [...starters, ...newBench.slice(0, 4)];
+}
+
+export function countSquadByPos(players) {
+ const c = { G: 0, D: 0, M: 0, F: 0 };
+ players.filter((p) => !p.isBlank && p.Pos).forEach((p) => {
+ if (c[p.Pos] !== undefined) c[p.Pos] += 1;
+ });
+ return c;
+}
+
+export function isValidFplSquad(players) {
+ const c = countSquadByPos(players);
+ return c.G === 2 && c.D === 5 && c.M === 5 && c.F === 3;
+}
+
+export const getOptimalLayout = (players, gw) => {
+ if (!players.length || !gw || players.some((p) => p.isBlank)) return null;
+ const getEV = (p) => Number(p[`${gw}_Pts`]) || 0;
+
+ let gks = players.filter((p) => p.Pos === "G").sort((a, b) => getEV(b) - getEV(a));
+ let defs = players.filter((p) => p.Pos === "D").sort((a, b) => getEV(b) - getEV(a));
+ let mids = players.filter((p) => p.Pos === "M").sort((a, b) => getEV(b) - getEV(a));
+ let fwds = players.filter((p) => p.Pos === "F").sort((a, b) => getEV(b) - getEV(a));
+
+ const starters = [];
+ if (gks.length) starters.push(gks.shift());
+ starters.push(...defs.splice(0, 3), ...mids.splice(0, 2), ...fwds.splice(0, 1));
+
+ const remaining = [...defs, ...mids, ...fwds].sort((a, b) => getEV(b) - getEV(a));
+ starters.push(...remaining.splice(0, 11 - starters.length));
+
+ const finalStarters = [
+ ...starters.filter((p) => p.Pos === "G"),
+ ...starters.filter((p) => p.Pos === "D"),
+ ...starters.filter((p) => p.Pos === "M"),
+ ...starters.filter((p) => p.Pos === "F"),
+ ];
+
+ const benchGk = gks.length ? gks[0] : null;
+ const benchRest = remaining.sort((a, b) => getEV(b) - getEV(a));
+ const bench = benchGk ? [benchGk, ...benchRest] : benchRest;
+ const topStarters = [...finalStarters].sort((a, b) => getEV(b) - getEV(a));
+
+ return {
+ optimalArray: [...finalStarters, ...bench],
+ cap: topStarters[0]?.ID,
+ vice: topStarters[1]?.ID,
+ };
+};
\ No newline at end of file
diff --git a/frontend/src/utils/teams.js b/frontend/src/utils/teams.js
new file mode 100644
index 0000000000000000000000000000000000000000..5b0402a43fb0f082e7255cab742be769da19e603
--- /dev/null
+++ b/frontend/src/utils/teams.js
@@ -0,0 +1,12 @@
+export const TEAM_SHORTS = {
+ "Arsenal": "ARS", "Aston Villa": "AVL", "Burnley": "BUR", "AFC Bournemouth": "BOU",
+ "Brentford": "BRE", "Brighton and Hove Albion": "BHA", "Chelsea": "CHE",
+ "Crystal Palace": "CRY", "Everton": "EVE", "Fulham": "FUL", "Leeds United": "LEE",
+ "Liverpool": "LIV", "Manchester City": "MCI", "Manchester United": "MUN",
+ "Newcastle United": "NEW", "Nottingham Forest": "NFO", "Sunderland": "SUN",
+ "Tottenham Hotspur": "TOT", "West Ham United": "WHU", "Wolverhampton Wanderers": "WOL",
+ "Bournemouth": "BOU", "Brighton": "BHA", "Man City": "MCI", "Man Utd": "MUN",
+ "Newcastle": "NEW", "Nott'm Forest": "NFO", "Spurs": "TOT", "West Ham": "WHU", "Wolves": "WOL"
+};
+
+export const getShortName = (fullName) => TEAM_SHORTS[fullName] || fullName;
\ No newline at end of file
diff --git a/frontend/tailwind.config.js b/frontend/tailwind.config.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ae8f8a21ffc0a62ea1c88f3f73b9b785fddae4d
--- /dev/null
+++ b/frontend/tailwind.config.js
@@ -0,0 +1,22 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+ content: [
+ "./index.html",
+ "./src/**/*.{js,ts,jsx,tsx}",
+ ],
+ theme: {
+ extend: {
+ colors: {
+ // Adding some custom Luigi's Mansion ghostly greens
+ luigi: {
+ 400: '#34d399',
+ 500: '#10b981',
+ 900: '#064e3b',
+ }
+ }
+ },
+ },
+ plugins: [],
+}
+
+
diff --git a/frontend/vite.config.js b/frontend/vite.config.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b0f57b91aeb45c54467e29f983a0893dc83c4d9
--- /dev/null
+++ b/frontend/vite.config.js
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+ plugins: [react()],
+})
diff --git a/logos/1044.png b/logos/1044.png
new file mode 100644
index 0000000000000000000000000000000000000000..dc1ea6028b8984f02eee2d525604605d8c99414f
--- /dev/null
+++ b/logos/1044.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2703d4d22a050434985764fd8512bdc83dc967b022f854668811b03aa05f2155
+size 7589
diff --git a/logos/328.png b/logos/328.png
new file mode 100644
index 0000000000000000000000000000000000000000..d759816851e664ed7eb5eeea828fc074416016f8
--- /dev/null
+++ b/logos/328.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a418607981308fd980be2246d4885b2f6794ebad33e0980315dd90e392b707e5
+size 12909
diff --git a/logos/341.png b/logos/341.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b250c8ca2ac5737251581cbf9905e5ae95d78f4
--- /dev/null
+++ b/logos/341.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16e5872c0127c093f14e8338b2ba1d79bc307cc24dcc690ca820c85c3af056f0
+size 6893
diff --git a/logos/351.png b/logos/351.png
new file mode 100644
index 0000000000000000000000000000000000000000..4aaeee2d3da669a41fc6d79d2945e3c8b1db6647
--- /dev/null
+++ b/logos/351.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4098e62317e19e6dc92d806ded0e77ba7714b22728998466a441aef0c8e9025
+size 5102
diff --git a/logos/354.png b/logos/354.png
new file mode 100644
index 0000000000000000000000000000000000000000..5ae4596c2ca2a42031d7d7473594fb742a92a07e
--- /dev/null
+++ b/logos/354.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8cd5323ea26846f9991bd5604ae63e124f81e5e3feda7716a3f038ab5151458c
+size 15450
diff --git a/logos/397.png b/logos/397.png
new file mode 100644
index 0000000000000000000000000000000000000000..d4db6849e05fdcd5e8b5ac224ac44346fba39444
--- /dev/null
+++ b/logos/397.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2a60525561839e8a113d95ec80598f8398a28b568124e3d9b15c69c651f5d07
+size 7468
diff --git a/logos/402.png b/logos/402.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf51d87496c6b552a7580e53485564027d3138a0
--- /dev/null
+++ b/logos/402.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:165adcf2e24288dcabd3e5d5e5de3b83e58e7c549aaa2c6101a37159a12c1753
+size 15476
diff --git a/logos/563.png b/logos/563.png
new file mode 100644
index 0000000000000000000000000000000000000000..52bcb21e8b7ec046a864a7169bc2e0a7b331ca33
--- /dev/null
+++ b/logos/563.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11e0ae907552888ef9190265cdef5f9b0f3e23052575870dc9fcf47ddca71898
+size 6859
diff --git a/logos/57.png b/logos/57.png
new file mode 100644
index 0000000000000000000000000000000000000000..fce6b314c2e8c347d708f5b95c53f9ea048ee2be
--- /dev/null
+++ b/logos/57.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36e761b46213d8fa6deb1ddd94add8b61060a74fab48ca77a1f28827ff37d209
+size 10279
diff --git a/logos/58.png b/logos/58.png
new file mode 100644
index 0000000000000000000000000000000000000000..98197d310f141b39c35baf07377d5f49edd38172
--- /dev/null
+++ b/logos/58.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd9d0e04bb7d781bca31fb8575de5ede409e4775db07a2cf64da7cbc3ee93202
+size 5924
diff --git a/logos/61.png b/logos/61.png
new file mode 100644
index 0000000000000000000000000000000000000000..61ca6ad7754f5c97ea0aecc53f2f00b5ee253e8f
--- /dev/null
+++ b/logos/61.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb79d3ccd973afb7802d4d48fb9b58de8940e9ac2183b66df28d83b61c1bfc6a
+size 14278
diff --git a/logos/62.png b/logos/62.png
new file mode 100644
index 0000000000000000000000000000000000000000..ac5484d9540a1a1de09c5d361f774602157fbef3
--- /dev/null
+++ b/logos/62.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d8062665589e8089e67175fe479efb2a647b6bd0ec7883a9602fc9557a788d7
+size 12393
diff --git a/logos/63.png b/logos/63.png
new file mode 100644
index 0000000000000000000000000000000000000000..1885a205ecb2dd3e78c7608c9dfc71d12c8826b3
--- /dev/null
+++ b/logos/63.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c84fb63fdd0a20e9268e2e5d967fd459b15c1e4194f8d4197a84a071b68187e2
+size 3728
diff --git a/logos/64.png b/logos/64.png
new file mode 100644
index 0000000000000000000000000000000000000000..466b465442e1585ebdbe29ba4095cf70a884422a
--- /dev/null
+++ b/logos/64.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e98ce271542dfc14ecaee2b5b6b228841a8ca19751f537eacec2fe66820fbcce
+size 15035
diff --git a/logos/65.png b/logos/65.png
new file mode 100644
index 0000000000000000000000000000000000000000..be37e5d5e93879c1dd73b34441bd3973a4a24ac5
--- /dev/null
+++ b/logos/65.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3602d5a8ecc240c6685d935a502fe56167d127ee53810e3ff618d2bba9db432
+size 14815
diff --git a/logos/66.png b/logos/66.png
new file mode 100644
index 0000000000000000000000000000000000000000..7161781abc29de26f21e15e2732788ef36245df9
--- /dev/null
+++ b/logos/66.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5bd8bd07d24ac133a75c2c7d93886b5d586cb84a41281378a98b0ef827850846
+size 16317
diff --git a/logos/67.png b/logos/67.png
new file mode 100644
index 0000000000000000000000000000000000000000..d965b4266bd6ab64c8e65868fbcf30655c61bcfb
--- /dev/null
+++ b/logos/67.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93ac1da648d20a87e9661564752e32f7d7be2e3d835917807207713149f2b571
+size 16245
diff --git a/logos/71.png b/logos/71.png
new file mode 100644
index 0000000000000000000000000000000000000000..94f9cb67aff36c70a5faa93cd1bb66ef0645dba2
--- /dev/null
+++ b/logos/71.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7690bab9be9d1712314b3982efcca442649f9ea75ad9ca3c4cce54c3621a35aa
+size 11052
diff --git a/logos/73.png b/logos/73.png
new file mode 100644
index 0000000000000000000000000000000000000000..2597048b64a8bdb6d8917c363e48b62f11eff3d3
--- /dev/null
+++ b/logos/73.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cfcd7ca5dd94737e52e965f5a44de45da5d08181410737722cd7d9929c5b1a4
+size 4281
diff --git a/logos/76.png b/logos/76.png
new file mode 100644
index 0000000000000000000000000000000000000000..bdb29e165a4f903687deed35c220fad4b8b50316
--- /dev/null
+++ b/logos/76.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab19a729b23877189ac54b7ff7c5b8c10d46adcea98d04b782beff0d4380e950
+size 3038
diff --git a/main.py b/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..97ca6f2f86a3ab75a0bf002af61cf743ddbc5a60
--- /dev/null
+++ b/main.py
@@ -0,0 +1,1148 @@
+import itertools as _itertools
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+import pandas as pd
+import requests
+from fastapi import FastAPI, HTTPException, APIRouter, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+from sqlalchemy.orm.attributes import flag_modified
+
+import engine
+from auth import router as auth_router
+from fpl_api import get_fpl_team_data
+from solver import run_milp_model
+from solver_engine import prep_solver_data
+from database import get_db, User, SessionLocal, GlobalConfig
+
+
+# --- PYDANTIC MODELS FOR REACT PAYLOAD ---
+class PlayerData(BaseModel):
+ id: int
+ name: str
+ pos: str
+ team: str
+ now_cost: float
+ sell_price: Optional[float] = None
+ evs: Dict[str, float] # JSON keys are strings; horizon GW keyed
+
+
+class SolveRequest(BaseModel):
+ team_id: int
+ horizon_gws: List[int]
+ current_squad_ids: List[Any]
+ market_players: List[PlayerData]
+ in_the_bank: float
+ free_transfers: int
+ settings: dict = {}
+ comprehensive_settings: dict = {}
+
+
+class ChipSolveRequest(BaseModel):
+ team_id: int
+ horizon_gws: List[int]
+ current_squad_ids: List[Any]
+ market_players: List[PlayerData]
+ in_the_bank: float
+ free_transfers: int
+ settings: dict = {}
+ comprehensive_settings: dict = {}
+ # { "wc": [gw, ...], "fh": [gw, ...], "bb": [gw, ...], "tc": [gw, ...] }
+ chip_gw_options: Dict[str, List[int]] = {}
+
+
+class SettingsPayload(BaseModel):
+ team_id: int
+ quick_settings: Dict[str, Any]
+ advanced_settings: Dict[str, Any]
+
+
+app = FastAPI(title="Luigi's Mansion FPL API")
+
+
+@app.get("/")
+def read_root():
+ return {
+ "status": "success",
+ "message": "Luigi's Mansion FPL Solver API is live and running!",
+ }
+
+
+app.include_router(auth_router)
+
+app.add_middleware(
+ CORSMiddleware,
+ allow_origins=["*"],
+ allow_credentials=True,
+ allow_methods=["*"],
+ allow_headers=["*"],
+)
+
+ADMIN_PASSWORD = "Monkeyrocks11$$"
+TEAMS_DICT = {
+ "Arsenal": 1,
+ "Aston Villa": 2,
+ "Burnley": 3,
+ "AFC Bournemouth": 4,
+ "Brentford": 5,
+ "Brighton and Hove Albion": 6,
+ "Chelsea": 7,
+ "Crystal Palace": 8,
+ "Everton": 9,
+ "Fulham": 10,
+ "Leeds United": 11,
+ "Liverpool": 12,
+ "Manchester City": 13,
+ "Manchester United": 14,
+ "Newcastle United": 15,
+ "Nottingham Forest": 16,
+ "Sunderland": 17,
+ "Tottenham Hotspur": 18,
+ "West Ham United": 19,
+ "Wolverhampton Wanderers": 20,
+}
+TEAMS_DICT_REVERSE = {v: k for k, v in TEAMS_DICT.items()}
+POS_MAP = {1: "G", 2: "D", 3: "M", 4: "F"}
+
+POINTS_CONFIG = {
+ "goal": {1: 10, 2: 6, 3: 5, 4: 4},
+ "assist": 3,
+ "clean_sheet": {1: 4, 2: 4, 3: 1, 4: 0},
+ "saves_per_3": 1,
+ "penalty_points_per_position": {2: 0.9, 3: 0.7, 4: 0.5},
+}
+
+
+class AppData:
+ finalized_df = None
+ match_df = None
+ output_df = None
+
+ # All JSON States
+ player_penalty_shares = {}
+ admin_xmins_overrides = {}
+ admin_baseline_overrides = {}
+ player_status_overrides = {}
+ availability_multipliers = {}
+ admin_fixture_overrides = {}
+
+ decay_rates = {
+ "default": 0.99,
+ "suspended": 0.99,
+ "injured_decay": 0.99,
+ "rotational_risk": 0.95,
+ }
+ ramp_up_rates = {
+ "default": 3,
+ "injured": 9,
+ "suspended": 3,
+ "starter": 0,
+ "rotational_risk": 2,
+ }
+ MINS_THRESHOLD = 30
+ RAMP_UP_PERIOD = 3
+
+
+app_data = AppData()
+
+
+def load_db_int_keys(db_key, default):
+ db = SessionLocal()
+ try:
+ config = db.query(GlobalConfig).filter(GlobalConfig.key == db_key).first()
+ if config and config.value:
+ return {int(k): v for k, v in config.value.items()}
+ finally:
+ db.close()
+ return default
+
+
+def load_db_string_keys(db_key, default):
+ db = SessionLocal()
+ try:
+ config = db.query(GlobalConfig).filter(GlobalConfig.key == db_key).first()
+ if config and config.value:
+ return config.value
+ finally:
+ db.close()
+ return default
+
+
+def save_config_to_db(db_key, value):
+ db = SessionLocal()
+ try:
+ config = db.query(GlobalConfig).filter(GlobalConfig.key == db_key).first()
+ if config:
+ config.value = value
+ flag_modified(config, "value")
+ else:
+ config = GlobalConfig(key=db_key, value=value)
+ db.add(config)
+ db.commit()
+ finally:
+ db.close()
+
+
+def load_fpl_data():
+ print("Fetching FPL API data...")
+ r = requests.get(
+ "https://fantasy.premierleague.com/api/bootstrap-static/", timeout=10
+ ).json()
+
+ players = pd.DataFrame(r["elements"])
+ players["name"] = players["first_name"] + " " + players["second_name"]
+ players = players[
+ [
+ "id",
+ "name",
+ "web_name",
+ "element_type",
+ "now_cost",
+ "team",
+ "chance_of_playing_this_round",
+ "news",
+ "photo",
+ ]
+ ]
+ players["now_cost"] = players["now_cost"] / 10
+
+ if os.path.exists("rename.json"):
+ with open("rename.json", "r", encoding="utf-8") as f:
+ players["name"] = players["name"].replace(json.load(f))
+
+ print("Loading baseline stats...")
+ gk_stats_df = pd.read_csv("statistical_weighted_baselines_gk.csv").rename(
+ columns=lambda x: x.strip()
+ )
+ outfield_stats_df = pd.read_csv("statistical_weighted_baselines.csv").rename(
+ columns=lambda x: x.strip()
+ )
+ gk_stats_df["player_name"] = gk_stats_df["player_name"].str.strip()
+ outfield_stats_df["player_name"] = outfield_stats_df["player_name"].str.strip()
+
+ gk_mask = players["element_type"] == 1
+ gk_merged = players[gk_mask].merge(
+ gk_stats_df, left_on="name", right_on="player_name", how="left"
+ )
+ outfield_merged = players[~gk_mask].merge(
+ outfield_stats_df, left_on="name", right_on="player_name", how="left"
+ )
+
+ final_df = (
+ pd.concat([gk_merged, outfield_merged], ignore_index=True)
+ .sort_values("id")
+ .reset_index(drop=True)
+ )
+ final_df.fillna(0, inplace=True)
+
+ final_df["Avg_BPS"] = 0.0
+ final_df.loc[final_df["element_type"] == 1, "Avg_BPS"] = final_df[
+ "baseline_gk_bps_p90"
+ ].astype(float)
+ final_df.loc[final_df["element_type"] == 2, "Avg_BPS"] = (
+ final_df["baseline_Neutral_BPS_p90"] + final_df["baseline_Def_BPS_p90"]
+ )
+ final_df.loc[final_df["element_type"] == 3, "Avg_BPS"] = (
+ final_df["baseline_Neutral_BPS_p90"] + final_df["baseline_Mid_BPS_p90"]
+ )
+ final_df.loc[final_df["element_type"] == 4, "Avg_BPS"] = (
+ final_df["baseline_Neutral_BPS_p90"] + final_df["baseline_Fwd_BPS_p90"]
+ )
+
+ print("Loading team and match projections...")
+ team_baselines = pd.read_excel("team_totals.xlsx", sheet_name="Sheet2")
+ team_baselines["Teams"] = team_baselines["Teams"].replace(TEAMS_DICT)
+
+ for stat in ["xG", "xA", "CBIT", "CBITR", "YC", "RC"]:
+ final_df[f"Team_{stat}"] = final_df["team"].map(
+ team_baselines.set_index("Teams")[stat].to_dict()
+ )
+
+ final_df["Team"] = final_df["team"].map(TEAMS_DICT_REVERSE)
+
+ final_df["xG_share"] = final_df["baseline_xG_p90"] / final_df["Team_xG"].replace(
+ 0, np.nan
+ )
+ final_df["xA_share"] = final_df["baseline_xA_p90"] / final_df["Team_xA"].replace(
+ 0, np.nan
+ )
+ final_df["xCBIT_share"] = final_df["baseline_CBIT_p90"] / final_df[
+ "Team_CBIT"
+ ].replace(0, np.nan)
+ final_df["xCBITR_share"] = final_df["baseline_CBITR_p90"] / final_df[
+ "Team_CBITR"
+ ].replace(0, np.nan)
+ final_df["YC_share"] = final_df["baseline_yc_p90"] / final_df["Team_YC"].replace(
+ 0, np.nan
+ )
+ final_df["RC_share"] = final_df["baseline_rc_p90"] / final_df["Team_RC"].replace(
+ 0, np.nan
+ )
+ final_df.fillna(0, inplace=True)
+
+ match_df = pd.read_csv("ewmapois_model.csv").rename(columns=lambda x: x.strip())
+ match_df["home_team_num"] = match_df["home_team"].map(TEAMS_DICT)
+ match_df["away_team_num"] = match_df["away_team"].map(TEAMS_DICT)
+
+ app_data.finalized_df = final_df
+ app_data.match_df = match_df
+
+ # --- LOAD ALL DB OVERRIDES ---
+ app_data.player_penalty_shares = load_db_int_keys(
+ "penalty_shares", {16: 0.65, 17: 0.15}
+ )
+
+ raw_xmins = load_db_int_keys("admin_xmins", {})
+ processed_overrides = {}
+ for pid, gws in raw_xmins.items():
+ processed_gws = {}
+ for gw_key, val in gws.items():
+ if str(gw_key).isdigit():
+ processed_gws[int(gw_key)] = val
+ else:
+ processed_gws[str(gw_key)] = val
+ processed_overrides[int(pid)] = processed_gws
+ app_data.admin_xmins_overrides = processed_overrides
+
+ app_data.admin_baseline_overrides = load_db_int_keys("admin_baselines", {})
+ app_data.player_status_overrides = load_db_int_keys("player_status", {})
+ app_data.availability_multipliers = load_db_int_keys("availability", {})
+ app_data.admin_fixture_overrides = load_db_string_keys("admin_fixtures", {})
+
+ # --- THE FALLBACK LOGIC ---
+ # Apply baseline JSON overrides on top of the CSV data. If not in JSON, it naturally keeps the CSV data.
+ for pid, overrides in app_data.admin_baseline_overrides.items():
+ if pid in app_data.finalized_df["id"].values:
+ if "baseline_xMins" in overrides:
+ app_data.finalized_df.loc[
+ app_data.finalized_df["id"] == pid, "baseline_xMins"
+ ] = overrides["baseline_xMins"]
+
+ print("Running initial FPL point engine...")
+ app_data.output_df = engine.calculate_all_points(
+ player_df_base=app_data.finalized_df,
+ match_df=app_data.match_df,
+ player_penalty_shares=app_data.player_penalty_shares,
+ MINS_SCALING_BONUS=0.0,
+ pos_map=POS_MAP,
+ teams_dict_1=TEAMS_DICT_REVERSE,
+ teams_dict=TEAMS_DICT,
+ points_config=POINTS_CONFIG,
+ effective_xmins_overrides=app_data.admin_xmins_overrides,
+ MINS_THRESHOLD=app_data.MINS_THRESHOLD,
+ RAMP_UP_PERIOD=app_data.RAMP_UP_PERIOD,
+ decay_rates=app_data.decay_rates,
+ ramp_up_rates=app_data.ramp_up_rates,
+ user_player_status_overrides=app_data.player_status_overrides,
+ team_skepticism={},
+ effective_availability_multipliers=app_data.availability_multipliers,
+ )
+
+ # Inject baseline_xMins into the output so the frontend can display it
+ app_data.output_df["baseline_xMins"] = app_data.output_df["ID"].map(
+ app_data.finalized_df.set_index("id")["baseline_xMins"]
+ )
+ # --- BULLETPROOF ADVANCED STATS INJECTION ---
+ try:
+ finalized_idx = app_data.finalized_df.set_index("id")
+
+ # 1. Add photo and Price so Transfer Market can display images and cost
+ if "photo" in finalized_idx.columns:
+ app_data.output_df["photo"] = app_data.output_df["ID"].map(
+ finalized_idx["photo"]
+ )
+ if "now_cost" in finalized_idx.columns:
+ app_data.output_df["Price"] = app_data.output_df["ID"].map(
+ finalized_idx["now_cost"]
+ )
+
+ # 2. Safely map xG and xA
+ app_data.output_df["xG"] = app_data.output_df["ID"].map(
+ lambda pid: round(
+ (finalized_idx.loc[pid, "baseline_xG_p90"] / 90)
+ * finalized_idx.loc[pid, "baseline_xMins"],
+ 2,
+ )
+ if pid in finalized_idx.index and "baseline_xG_p90" in finalized_idx.columns
+ else 0
+ )
+ app_data.output_df["xA"] = app_data.output_df["ID"].map(
+ lambda pid: round(
+ (finalized_idx.loc[pid, "baseline_xA_p90"] / 90)
+ * finalized_idx.loc[pid, "baseline_xMins"],
+ 2,
+ )
+ if pid in finalized_idx.index and "baseline_xA_p90" in finalized_idx.columns
+ else 0
+ )
+
+ # 3. Safely get CS%
+ unique_gws = sorted(app_data.match_df["GW"].unique())
+ for gw in unique_gws:
+ if f"{gw}_xG" in app_data.output_df.columns:
+ # Format CS% for the GW
+ app_data.output_df[f"{gw}_CS_Pct"] = (
+ app_data.output_df[f"{gw}_CS"] * 100
+ ).apply(lambda x: f"{x:.0f}%")
+
+ # Calculate HIT% for the GW using the stored CBIT / CBITR
+ def calc_hit_gw(row):
+ pos = row["Pos"]
+ if pos == "D":
+ cbit = row.get(f"{gw}_cbit", 0)
+ prob = engine.neg_binom_probability_at_least(
+ cbit, 10, dispersion=3.2
+ )
+ elif pos == "M":
+ cbitr = row.get(f"{gw}_cbitr", 0)
+ prob = engine.neg_binom_probability_at_least(
+ cbitr, 12, dispersion=2.8
+ )
+ elif pos == "F":
+ cbitr = row.get(f"{gw}_cbitr", 0)
+ prob = engine.neg_binom_probability_at_least(
+ cbitr, 12, dispersion=1.7
+ )
+ else:
+ return "-"
+ return f"{prob * 100:.0f}%"
+
+ app_data.output_df[f"{gw}_DefconHit"] = app_data.output_df.apply(
+ calc_hit_gw, axis=1
+ )
+
+ except Exception as e:
+ print(f"WARNING: Could not inject advanced stats. Reason: {e}")
+
+
+@app.on_event("startup")
+def startup_event():
+ load_fpl_data()
+
+
+@app.get("/api/projections")
+def get_projections():
+ if app_data.output_df is None:
+ raise HTTPException(status_code=503, detail="Loading")
+ clean_df = app_data.output_df.where(pd.notnull(app_data.output_df), None)
+ return clean_df.to_dict(orient="records")
+
+
+class UpdateRequest(BaseModel):
+ player_id: int
+ baseline_edit: Optional[float] = None
+ gw_edits: Dict[str, float] = {}
+ is_admin: bool = False
+ admin_password: Optional[str] = None
+
+
+@app.post("/api/player/update")
+def update_player(req: UpdateRequest):
+ if req.is_admin:
+ if req.admin_password != ADMIN_PASSWORD:
+ raise HTTPException(status_code=401, detail="Invalid admin password")
+
+ # Save Admin Edits directly to the JSON files
+ if req.baseline_edit is not None:
+ if req.player_id not in app_data.admin_baseline_overrides:
+ app_data.admin_baseline_overrides[req.player_id] = {}
+ app_data.admin_baseline_overrides[req.player_id]["baseline_xMins"] = (
+ req.baseline_edit
+ )
+ save_config_to_db("admin_baselines", app_data.admin_baseline_overrides)
+
+ for gw_str, xmins in req.gw_edits.items():
+ gw_key = int(gw_str) if str(gw_str).isdigit() else str(gw_str)
+ if req.player_id not in app_data.admin_xmins_overrides:
+ app_data.admin_xmins_overrides[req.player_id] = {}
+ app_data.admin_xmins_overrides[req.player_id][gw_key] = xmins
+ if req.gw_edits:
+ save_config_to_db("admin_xmins", app_data.admin_xmins_overrides)
+
+ player_df = app_data.finalized_df[
+ app_data.finalized_df["id"] == req.player_id
+ ].copy()
+ if player_df.empty:
+ raise HTTPException(status_code=404, detail="Player not found")
+
+ current_baseline = player_df.iloc[0]["baseline_xMins"]
+ if req.baseline_edit is not None:
+ player_df["baseline_xMins"] = req.baseline_edit
+ current_baseline = req.baseline_edit
+
+ effective_overrides = {
+ req.player_id: app_data.admin_xmins_overrides.get(req.player_id, {}).copy()
+ }
+ for gw_str, val in req.gw_edits.items():
+ gw_key = int(gw_str) if str(gw_str).isdigit() else str(gw_str)
+ effective_overrides[req.player_id][gw_key] = val
+
+ # Recalculate using all the existing status/penalty configs
+ updated_row_df = engine.calculate_all_points(
+ player_df_base=player_df,
+ match_df=app_data.match_df,
+ player_penalty_shares=app_data.player_penalty_shares,
+ MINS_SCALING_BONUS=0.0,
+ pos_map=POS_MAP,
+ teams_dict_1=TEAMS_DICT_REVERSE,
+ teams_dict=TEAMS_DICT,
+ points_config=POINTS_CONFIG,
+ effective_xmins_overrides=effective_overrides,
+ MINS_THRESHOLD=app_data.MINS_THRESHOLD,
+ RAMP_UP_PERIOD=app_data.RAMP_UP_PERIOD,
+ decay_rates=app_data.decay_rates,
+ ramp_up_rates=app_data.ramp_up_rates,
+ user_player_status_overrides=app_data.player_status_overrides,
+ team_skepticism={},
+ effective_availability_multipliers=app_data.availability_multipliers,
+ )
+
+ updated_row_df["baseline_xMins"] = current_baseline
+ if req.is_admin and app_data.output_df is not None:
+ idx = app_data.output_df[app_data.output_df["ID"] == req.player_id].index
+ if not idx.empty:
+ for col in updated_row_df.columns:
+ if col in app_data.output_df.columns:
+ app_data.output_df.loc[idx, col] = updated_row_df[col].values[0]
+ return updated_row_df.iloc[0].to_dict()
+
+
+@app.get("/api/ratings")
+def get_ratings():
+ import base64
+
+ if os.path.exists("team_ratings_dual_speed.csv"):
+ df = pd.read_csv("team_ratings_dual_speed.csv")
+ df.rename(columns=lambda x: x.strip(), inplace=True)
+
+ # Team IDs mapping for the logos
+ team_ids = {
+ "Arsenal": 57,
+ "Manchester City": 65,
+ "Liverpool": 64,
+ "Chelsea": 61,
+ "Newcastle United": 67,
+ "Aston Villa": 58,
+ "Manchester United": 66,
+ "Brentford": 402,
+ "Brighton and Hove Albion": 397,
+ "AFC Bournemouth": 1044,
+ "Tottenham Hotspur": 73,
+ "Crystal Palace": 354,
+ "Fulham": 63,
+ "Nottingham Forest": 351,
+ "Everton": 62,
+ "Leeds United": 341,
+ "West Ham United": 563,
+ "Wolverhampton Wanderers": 76,
+ "Sunderland": 71,
+ "Burnley": 328,
+ }
+
+ def get_logo(t_name):
+ tid = team_ids.get(t_name)
+ logo_path = f"logos/{tid}.png"
+ if tid and os.path.exists(logo_path):
+ with open(logo_path, "rb") as f:
+ return (
+ "data:image/png;base64," + base64.b64encode(f.read()).decode()
+ )
+ return None
+
+ df["Logo"] = df["Team"].apply(get_logo)
+ return df.to_dict(orient="records")
+ return []
+
+
+@app.get("/api/fixtures")
+def get_fixtures():
+ if app_data.match_df is not None:
+ cols = [
+ "GW",
+ "home_team",
+ "away_team",
+ "home_win_prob",
+ "draw_prob",
+ "away_win_prob",
+ "expected_home_goals",
+ "expected_away_goals",
+ "home_clean_sheet_odds",
+ "away_clean_sheet_odds",
+ ]
+ df = app_data.match_df[cols].copy()
+
+ for col in [
+ "home_win_prob",
+ "draw_prob",
+ "away_win_prob",
+ "expected_home_goals",
+ "expected_away_goals",
+ "home_clean_sheet_odds",
+ "away_clean_sheet_odds",
+ ]:
+ df[col] = df[col].astype(float).round(3)
+
+ return df.to_dict(orient="records")
+ return []
+
+
+@app.get("/api/accuracy/players")
+def get_accuracy_players():
+ import os
+
+ import pandas as pd
+
+ file_path = "points_check.xlsx"
+ if os.path.exists(file_path):
+ df = pd.read_excel(file_path)
+ df.columns = df.columns.str.strip()
+ df.fillna(0, inplace=True)
+ return df.to_dict(orient="records")
+
+ # Fallback just in case
+ csv_path = "points_check.xlsx - Sheet1.csv"
+ if os.path.exists(csv_path):
+ df = pd.read_csv(csv_path)
+ df.columns = df.columns.str.strip()
+ df.fillna(0, inplace=True)
+ return df.to_dict(orient="records")
+ return []
+
+
+@app.get("/api/accuracy/matches")
+def get_accuracy_matches():
+ import os
+
+ import pandas as pd
+
+ file_path = "projections_check.xlsx"
+ if os.path.exists(file_path):
+ df = pd.read_excel(file_path)
+ df.columns = df.columns.str.strip()
+ df.fillna(0, inplace=True)
+ return df.to_dict(orient="records")
+
+ # Fallback just in case
+ csv_path = "projections_check.xlsx - Sheet1.csv"
+ if os.path.exists(csv_path):
+ df = pd.read_csv(csv_path)
+ df.columns = df.columns.str.strip()
+ df.fillna(0, inplace=True)
+ return df.to_dict(orient="records")
+ return []
+
+
+@app.get("/api/manager/{team_id}")
+async def get_manager_team(team_id: int):
+ try:
+ # 1. Run the precise open-fpl-solver logic to get ITB, FTs, and Selling Prices
+ fpl_data = get_fpl_team_data(team_id)
+
+ team_data = []
+
+ # 2. Merge the official FPL data with your local Projection Data
+ for pick in fpl_data["squad"]:
+ pid = pick["id"]
+
+ # Find the player in your master projections dataframe
+ proj_row = app_data.output_df[app_data.output_df["ID"] == pid]
+ if proj_row.empty:
+ continue
+
+ proj_dict = proj_row.iloc[0].to_dict()
+
+ # --- CRITICAL FIX: TRUE SELLING PRICE ---
+ # Overwrite the global "Cost Price" with the user's personal "Selling Price"
+ proj_dict["Price"] = pick["selling_price"]
+
+ # Add photos if needed
+ base_row = app_data.finalized_df[app_data.finalized_df["id"] == pid]
+ proj_dict["photo"] = (
+ base_row.iloc[0]["photo"]
+ if not base_row.empty and "photo" in base_row.columns
+ else ""
+ )
+
+ team_data.append(proj_dict)
+
+ # 3. Send the exact payload React is expecting!
+ return {
+ "in_the_bank": fpl_data["in_the_bank"],
+ "free_transfers": fpl_data["free_transfers"],
+ "picks": team_data,
+ }
+
+ except Exception as e:
+ print(f"Error fetching team: {e}")
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+def _load_default_solver_settings() -> dict:
+ path = os.path.join(os.path.dirname(__file__), "comprehensive_settings.json")
+ if os.path.exists(path):
+ with open(path, "r", encoding="utf-8") as f:
+ return json.load(f)
+ return {}
+
+
+@app.get("/api/solver/default-settings")
+def get_solver_default_settings():
+ return _load_default_solver_settings()
+
+
+@app.post("/api/solve")
+async def run_solver(payload: SolveRequest):
+ try:
+ data_dict = (
+ payload.model_dump() if hasattr(payload, "model_dump") else payload.dict()
+ )
+
+ # 2. Run the Data Prepper
+ solver_input = prep_solver_data(data_dict)
+
+ # 3. Run the Math Engine
+ optimal_moves = run_milp_model(solver_input)
+
+ return optimal_moves
+ except Exception as e:
+ print(f"Error: {e}")
+ raise HTTPException(status_code=400, detail=str(e))
+
+
+class SensitivityRequest(SolveRequest):
+ num_sims: int = 50
+ analysis_gw: Optional[int] = None # kept for compat, ignored internally
+
+
+@app.post("/api/sensitivity")
+async def run_sensitivity_analysis(payload: SensitivityRequest):
+ """
+ Runs num_sims solves (iterations=1, per-player noise). For regular GWs
+ aggregates buy/sell/move transfers; for WC/FH GWs aggregates squad
+ selection % (PSB), lineup %, and positional lineup combinations.
+ """
+ import random
+ from collections import Counter
+
+ try:
+ data_dict = (
+ payload.model_dump() if hasattr(payload, "model_dump") else payload.dict()
+ )
+ num_sims = int(data_dict.pop("num_sims", 50))
+ data_dict.pop("analysis_gw", None)
+ horizon_gws = [int(g) for g in data_dict.get("horizon_gws", [])]
+
+ base_settings = dict(data_dict.get("settings") or {})
+ base_settings["iterations"] = 1
+
+ # Detect which GWs have WC/FH active
+ chip_free_gws: set[int] = set()
+ for chip_key in ("use_wc", "use_fh"):
+ for g in base_settings.get(chip_key) or []:
+ chip_free_gws.add(int(g))
+
+ id_to_name: dict[int, str] = {}
+ id_to_pos: dict[int, str] = {}
+ for p in data_dict["market_players"]:
+ pid = int(p["id"])
+ id_to_name[pid] = p["name"]
+ id_to_pos[pid] = p["pos"]
+
+ print(
+ f"Sensitivity: running {num_sims} sims across {len(horizon_gws)} GWs "
+ f"(chip-free GWs: {chip_free_gws or 'none'})..."
+ )
+
+ # Regular GW accumulators
+ gw_data: dict[int, dict] = {
+ gw: {"buys": {}, "sells": {}, "moves": {}, "lineups": {}, "no_transfer": 0}
+ for gw in horizon_gws
+ if gw not in chip_free_gws
+ }
+
+ # WC/FH GW accumulators: per-player squad & lineup counts + combo counters
+ wc_data: dict[int, dict] = {
+ gw: {
+ "squad": {}, # {name: count} (in the 15-man squad)
+ "lineup": {}, # {name: count} (in the 11-man lineup)
+ "combos": {
+ "G": Counter(),
+ "D": Counter(),
+ "M": Counter(),
+ "F": Counter(),
+ },
+ }
+ for gw in horizon_gws
+ if gw in chip_free_gws
+ }
+
+ valid_runs = 0
+
+ for sim_idx in range(num_sims):
+ noisy_players = []
+ for p in data_dict["market_players"]:
+ noise = random.gauss(1.0, 0.12)
+ noise = max(0.3, min(2.5, noise))
+ noisy_evs = {k: round(float(v) * noise, 4) for k, v in p["evs"].items()}
+ noisy_players.append({**p, "evs": noisy_evs})
+
+ sim_data = {
+ **data_dict,
+ "market_players": noisy_players,
+ "settings": {**base_settings},
+ }
+
+ try:
+ solver_input = prep_solver_data(sim_data)
+ result = run_milp_model(solver_input)
+ if result["status"] != "success" or not result["solutions"]:
+ continue
+ sol = result["solutions"][0]
+ except Exception as sim_err:
+ print(f" Sim {sim_idx + 1} failed: {sim_err}")
+ continue
+
+ valid_runs += 1
+
+ for gw_plan in sol["plan"]:
+ gw = gw_plan["gw"]
+
+ if gw in wc_data:
+ # --- WC/FH GW: squad & lineup selection ---
+ all_ids = list(gw_plan.get("lineup", [])) + list(
+ gw_plan.get("bench", [])
+ )
+ lineup_ids = set(gw_plan.get("lineup", []))
+ for pid in all_ids:
+ name = id_to_name.get(pid, str(pid))
+ wc_data[gw]["squad"][name] = (
+ wc_data[gw]["squad"].get(name, 0) + 1
+ )
+ if pid in lineup_ids:
+ wc_data[gw]["lineup"][name] = (
+ wc_data[gw]["lineup"].get(name, 0) + 1
+ )
+
+ # Lineup combos per position
+ for pid in lineup_ids:
+ pass # we accumulate below
+ pos_players: dict[str, list[str]] = {
+ "G": [],
+ "D": [],
+ "M": [],
+ "F": [],
+ }
+ for pid in sorted(lineup_ids):
+ pos = id_to_pos.get(pid, "M")
+ name = id_to_name.get(pid, str(pid))
+ if pos in pos_players:
+ pos_players[pos].append(name)
+ for pos, names in pos_players.items():
+ combo = frozenset(names)
+ if combo:
+ wc_data[gw]["combos"][pos][combo] += 1
+
+ elif gw in gw_data:
+ # --- Regular GW: buy/sell/move ---
+ transfers_out_ids = gw_plan.get("transfers_out", [])
+ transfers_in_ids = gw_plan.get("transfers_in", [])
+
+ if not transfers_in_ids:
+ gw_data[gw]["no_transfer"] += 1
+ else:
+ buy_names = [
+ id_to_name.get(pid, str(pid)) for pid in transfers_in_ids
+ ]
+ sell_names = [
+ id_to_name.get(pid, str(pid)) for pid in transfers_out_ids
+ ]
+ for name in buy_names:
+ gw_data[gw]["buys"][name] = (
+ gw_data[gw]["buys"].get(name, 0) + 1
+ )
+ for name in sell_names:
+ gw_data[gw]["sells"][name] = (
+ gw_data[gw]["sells"].get(name, 0) + 1
+ )
+
+ sorted_buys = sorted(buy_names)
+ sorted_sells = sorted(sell_names)
+ if sorted_buys and sorted_sells:
+ mk = (
+ f"{', '.join(sorted_sells)} -> {', '.join(sorted_buys)}"
+ )
+ gw_data[gw]["moves"][mk] = (
+ gw_data[gw]["moves"].get(mk, 0) + 1
+ )
+
+ for pid in gw_plan.get("lineup", []):
+ name = id_to_name.get(pid, str(pid))
+ gw_data[gw]["lineups"][name] = (
+ gw_data[gw]["lineups"].get(name, 0) + 1
+ )
+
+ if valid_runs == 0:
+ raise Exception(
+ "All sensitivity simulations failed. Check squad/budget settings."
+ )
+
+ def to_pct_list(counter: dict, top_n: int = 20) -> list:
+ return [
+ {"name": k, "count": v, "pct": round(v / valid_runs * 100, 1)}
+ for k, v in sorted(counter.items(), key=lambda x: -x[1])[:top_n]
+ ]
+
+ name_to_pos: dict[str, str] = {v: id_to_pos[k] for k, v in id_to_name.items()}
+
+ gw_results: dict[str, dict] = {}
+
+ # --- Regular GW results ---
+ for gw in horizon_gws:
+ if gw in chip_free_gws:
+ continue
+ if gw not in gw_data:
+ continue
+ d = gw_data[gw]
+ pos_groups: dict[str, list] = {"G": [], "D": [], "M": [], "F": []}
+ for name, cnt in sorted(d["lineups"].items(), key=lambda x: -x[1]):
+ pos = name_to_pos.get(name, "M")
+ pct = round(cnt / valid_runs * 100, 1)
+ if pos in pos_groups:
+ pos_groups[pos].append({"name": name, "pct": pct, "count": cnt})
+ gw_results[str(gw)] = {
+ "is_chip_free": False,
+ "buys": to_pct_list(d["buys"]),
+ "sells": to_pct_list(d["sells"]),
+ "moves": to_pct_list(d["moves"]),
+ "lineups": {pos: rows[:8] for pos, rows in pos_groups.items()},
+ "no_transfer_pct": round(d["no_transfer"] / valid_runs * 100, 1),
+ }
+
+ # --- WC/FH GW results ---
+ for gw in horizon_gws:
+ if gw not in wc_data:
+ continue
+ wd = wc_data[gw]
+
+ # Per-player squad/lineup pct grouped by position
+ player_data_by_pos: dict[str, list] = {"G": [], "D": [], "M": [], "F": []}
+ all_names = set(list(wd["squad"].keys()) + list(wd["lineup"].keys()))
+ for name in all_names:
+ sq_cnt = wd["squad"].get(name, 0)
+ lu_cnt = wd["lineup"].get(name, 0)
+ pos = name_to_pos.get(name, "M")
+ if pos in player_data_by_pos:
+ player_data_by_pos[pos].append(
+ {
+ "name": name,
+ "squad_pct": round(sq_cnt / valid_runs * 100, 1),
+ "lineup_pct": round(lu_cnt / valid_runs * 100, 1),
+ "squad_count": sq_cnt,
+ "lineup_count": lu_cnt,
+ }
+ )
+ # Sort each position by squad_pct descending
+ for pos in player_data_by_pos:
+ player_data_by_pos[pos].sort(key=lambda x: -x["squad_pct"])
+ player_data_by_pos[pos] = player_data_by_pos[pos][:12]
+
+ # Lineup combos per position (top 5)
+ combo_data: dict[str, list] = {}
+ for pos in ("G", "D", "M", "F"):
+ combos = wd["combos"][pos]
+ sorted_combos = sorted(combos.items(), key=lambda x: -x[1])[:5]
+ combo_data[pos] = [
+ {
+ "combination": ", ".join(sorted(combo)),
+ "pct": round(cnt / valid_runs * 100, 1),
+ "count": cnt,
+ }
+ for combo, cnt in sorted_combos
+ ]
+
+ gw_results[str(gw)] = {
+ "is_chip_free": True,
+ "players": player_data_by_pos,
+ "combos": combo_data,
+ }
+
+ return {
+ "status": "success",
+ "num_sims": num_sims,
+ "valid_runs": valid_runs,
+ "horizon_gws": horizon_gws,
+ "gw_results": gw_results,
+ }
+
+ except Exception as e:
+ print(f"Sensitivity error: {e}")
+ raise HTTPException(status_code=400, detail=str(e))
+
+
+def _generate_chip_combos(chip_gw_options: dict) -> list[dict]:
+ """
+ Generate all valid chip combinations from the per-chip GW option lists.
+ Rules:
+ - At most one chip per GW.
+ - Each chip type used at most once.
+ - Returns list of dicts like {"use_wc": [], "use_fh": [37], "use_bb": [33], "use_tc": []}.
+ """
+ chip_types = ["wc", "fh", "bb", "tc"]
+ options: list[list] = []
+ for c in chip_types:
+ gws = [int(g) for g in (chip_gw_options.get(c) or [])]
+ options.append([None] + gws) # None = don't use this chip
+
+ valid: list[dict] = []
+ for combo in _itertools.product(*options):
+ # combo = (wc_gw|None, fh_gw|None, bb_gw|None, tc_gw|None)
+ used_gws = [g for g in combo if g is not None]
+ if len(used_gws) != len(set(used_gws)):
+ continue # Two chips assigned to same GW — invalid
+ valid.append(
+ {
+ f"use_{c}": ([g] if g is not None else [])
+ for c, g in zip(chip_types, combo)
+ }
+ )
+ return valid
+
+
+@app.post("/api/chip-solve")
+async def run_chip_solver(payload: ChipSolveRequest):
+ """
+ Evaluate all valid chip combinations from the supplied option lists and
+ return the top solutions ranked by objective score.
+
+ Chip-solve uses fixed settings: decay=1.017, ft_value=0,
+ ft_value_list all zeros, itb_value=0, ft_use_penalty=0.
+ """
+ try:
+ data_dict = (
+ payload.model_dump() if hasattr(payload, "model_dump") else payload.dict()
+ )
+ chip_gw_options: dict = data_dict.pop("chip_gw_options", {})
+
+ # Fixed chip-solve settings (per run_parallel.py conventions)
+ chip_fixed = {
+ "decay": 1.017,
+ "ft_value": 0.0,
+ "ft_value_list": {"2": 0, "3": 0, "4": 0, "5": 0},
+ "itb_value": 0.0,
+ "ft_use_penalty": 0.0,
+ "no_transfer_last_gws": 0,
+ "iterations": 1,
+ }
+ base_settings = {**data_dict.get("settings", {}), **chip_fixed}
+
+ combos = _generate_chip_combos(chip_gw_options)
+ if not combos:
+ raise Exception(
+ "No valid chip combinations generated from the supplied GW options."
+ )
+
+ # Cap at 30 combinations to keep runtime reasonable
+ combos = combos[:30]
+ print(f"Chip solve: evaluating {len(combos)} valid chip combination(s)...")
+
+ all_solutions = []
+ for idx, combo in enumerate(combos):
+ combo_settings = {**base_settings, **combo}
+ combo_data = {**data_dict, "settings": combo_settings}
+ try:
+ solver_input = prep_solver_data(combo_data)
+ result = run_milp_model(solver_input)
+ if result["status"] == "success" and result["solutions"]:
+ sol = result["solutions"][0]
+ sol["chip_combo"] = combo # tag which chips were used
+ sol["combo_id"] = idx + 1
+ all_solutions.append(sol)
+ except Exception as combo_err:
+ print(f" Combo {idx + 1} ({combo}) failed: {combo_err}")
+ continue
+
+ if not all_solutions:
+ raise Exception("All chip combinations failed to find optimal solutions.")
+
+ all_solutions.sort(
+ key=lambda s: -(float(s.get("objective_score") or s.get("ev") or 0))
+ )
+
+ return {"status": "success", "solutions": all_solutions[:10]}
+
+ except Exception as e:
+ print(f"Chip solve error: {e}")
+ raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.post("/api/settings/save")
+async def save_user_settings(payload: SettingsPayload, db: Session = Depends(get_db)):
+ user = db.query(User).filter(User.default_team_id == payload.team_id).first()
+ if not user:
+ raise HTTPException(status_code=404, detail="User not found")
+
+ user.solver_settings = {
+ "quick": payload.quick_settings,
+ "advanced": payload.advanced_settings,
+ }
+
+ # THE FIX: Violently force SQLAlchemy to commit the JSON column
+ flag_modified(user, "solver_settings")
+
+ db.commit()
+ return {"status": "success", "message": "Settings saved to cloud."}
+
+
+# 3. The LOAD Route (GET)
+@app.get("/api/settings/{team_id}")
+async def load_user_settings(team_id: int, db: Session = Depends(get_db)):
+ # Find the user by their team_id
+ user = db.query(User).filter(User.default_team_id == team_id).first()
+
+ if not user or not user.solver_settings:
+ # If no user or no settings, return nulls so React uses local defaults
+ return {"status": "success", "quick_settings": None, "advanced_settings": None}
+
+ return {
+ "status": "success",
+ "quick_settings": user.solver_settings.get("quick"),
+ "advanced_settings": user.solver_settings.get("advanced"),
+ }
+
+
+class FixtureOverrideRequest(BaseModel):
+ overrides: Dict[str, Any]
+ is_admin: bool = False
+ admin_password: Optional[str] = None
+
+
+@app.get("/api/fixtures/overrides")
+def get_fixture_overrides():
+ # Serves the global fixtures to everyone who loads the website
+ return app_data.admin_fixture_overrides
+
+
+@app.post("/api/fixtures/update")
+def update_fixture_overrides(req: FixtureOverrideRequest):
+ if req.is_admin:
+ if req.admin_password != ADMIN_PASSWORD:
+ raise HTTPException(status_code=401, detail="Invalid admin password")
+
+ # 1. Update Python's active RAM instantly!
+ app_data.admin_fixture_overrides = req.overrides
+
+ # 2. Save it to the Hard Drive permanently
+ save_config_to_db("admin_fixtures", app_data.admin_fixture_overrides)
+
+ return {"status": "success", "message": "Global fixtures updated!"}
+
+ raise HTTPException(status_code=401, detail="Unauthorized")
+
+
+@app.get("/api/xmins/overrides")
+def get_xmins_overrides():
+ return app_data.admin_xmins_overrides
diff --git a/player_groups.json b/player_groups.json
new file mode 100644
index 0000000000000000000000000000000000000000..1523bee0b034df4e58c939210cd5653241d18159
--- /dev/null
+++ b/player_groups.json
@@ -0,0 +1,112 @@
+{
+ "arsenal attack 1": [
+ "Saka (16)",
+ "Gy\u00f6keres (666)",
+ "Madueke (18)",
+ "Eze (266)",
+ "Trossard (20)",
+ "Martinelli (19)"
+ ],
+ "bou attack 1": [
+ "Tavernier (84)",
+ "Kluivert (81)",
+ "Adli (697)",
+ "Brooks (86)"
+ ],
+ "bou attack 2": [
+ "Evanilson (97)",
+ "Kroupi.Jr (100)",
+ "Enes \u00dcnal (98)"
+ ],
+ "brentford 1": [
+ "O.Dango (83)",
+ "Schade (120)",
+ "Thiago (136)"
+ ],
+ "brighton 1": [
+ "Minteh (160)",
+ "Georginio (158)",
+ "Welbeck (178)",
+ "Mitoma (157)",
+ "Gruda (162)",
+ "Gomez (169)"
+ ],
+ "chelsea 1": [
+ "Palmer (235)",
+ "Enzo (237)",
+ "Buonanotte (168)"
+ ],
+ "chelsea 2": [
+ "Jo\u00e3o Pedro (249)",
+ "Delap (250)"
+ ],
+ "palace 2": [
+ "Sarr (267)",
+ "Yeremy (712)",
+ "Kamada (271)",
+ "Devenny (276)",
+ "Mateta (283)",
+ "Johnson (580)"
+ ],
+ "everton 1 ": [
+ "Beto (311)",
+ "Barry (310)"
+ ],
+ "everton 2": [
+ "Ndiaye (299)",
+ "McNeil (300)",
+ "Grealish (419)",
+ "Dewsbury-Hall (242)",
+ "Alcaraz (301)"
+ ],
+ "fulham 2": [
+ "Smith Rowe (325)",
+ "King (335)",
+ "Iwobi (324)",
+ "Wilson (329)",
+ "Chukwueze (727)",
+ "Muniz (338)",
+ "Ra\u00fal (337)"
+ ],
+ "leeds 1": [
+ "Calvert-Lewin (691)",
+ "Nmecha (365)",
+ "Okafor (698)"
+ ],
+ "liverpool 2": [
+ "M.Salah (381)",
+ "Szoboszlai (387)",
+ "Gakpo (384)",
+ "Mac Allister (386)",
+ "Wirtz (382)",
+ "Ekitik\u00e9 (661)",
+ "Isak (499)"
+ ],
+ "city 1": [
+ "Foden (414)",
+ "Cherki (417)",
+ "Reijnders (427)",
+ "Bernardo (416)",
+ "Doku (418)",
+ "Savinho (415)",
+ "Semenyo (82)",
+ "Haaland (430)"
+ ],
+ "newcastle 1": [
+ "Woltemade (714)",
+ "Wissa (135)"
+ ],
+ "newcastle 2": [
+ "Gordon (485)",
+ "Elanga (486)",
+ "J.Murphy (489)",
+ "Barnes (487)"
+ ],
+ "whu": [
+ "Bowen (624)",
+ "L.Paquet\u00e1 (612)",
+ "Taty (791)",
+ "Pablo (785)",
+ "Summerville (615)"
+ ]
+}
\ No newline at end of file
diff --git a/player_penalty_shares.json b/player_penalty_shares.json
new file mode 100644
index 0000000000000000000000000000000000000000..b7a62df76ebd5bf60a7a37c1d15808d110a4fb03
--- /dev/null
+++ b/player_penalty_shares.json
@@ -0,0 +1,76 @@
+{
+ "16": 0.45,
+ "17": 0.1,
+ "30": 0.05,
+ "666": 0.24,
+ "48": 0.25,
+ "64": 0.3,
+ "81": 0.9,
+ "699": 0.5,
+ "97": 0.05,
+ "136": 0.8,
+ "121": 0.09,
+ "178": 0.85,
+ "158": 0.18,
+ "202": 0.25,
+ "215": 0.41,
+ "216": 0.02,
+ "235": 0.9,
+ "236": 0.7,
+ "249": 0.1,
+ "266": 0.0,
+ "267": 0.1,
+ "283": 0.9,
+ "299": 0.8,
+ "311": 0.1,
+ "310": 0.1,
+ "337": 0.75,
+ "327": 0.0,
+ "343": 0.07,
+ "362": 0.7,
+ "381": 0.9,
+ "382": 0.0,
+ "386": 0.05,
+ "430": 0.93,
+ "413": 0.15,
+ "449": 0.89,
+ "119": 0.1,
+ "450": 0.0,
+ "499": 0.0,
+ "485": 0.5,
+ "474": 0.02,
+ "525": 0.4,
+ "515": 0.3,
+ "596": 0.7,
+ "612": 0.0,
+ "624": 0.84,
+ "625": 0.04,
+ "647": 0.1,
+ "654": 0.7,
+ "561": 0.6,
+ "663": 0.15,
+ "164": 0.75,
+ "597": 0.65,
+ "135": 0.0,
+ "82": 0.3,
+ "237": 0.0,
+ "691": 0.1,
+ "714": 0.23,
+ "547": 0.1,
+ "544": 0.6,
+ "84": 0.6,
+ "100": 0.4,
+ "517": 0.3,
+ "387": 0.35,
+ "120": 0.22,
+ "365": 0.4,
+ "681": 0.1,
+ "414": 0.2,
+ "526": 0.3,
+ "783": 0.1,
+ "791": 0.15,
+ "642": 0.65,
+ "817": 0.1,
+ "720": 0.0,
+ "709": 0.25
+}
\ No newline at end of file
diff --git a/points_check.xlsx b/points_check.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..7a291319266317b3377601e3558c9104cd6216c6
--- /dev/null
+++ b/points_check.xlsx
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74fad5732cfe070578e5723946bc86ae432f0f5deef2779c035a1c2f69102f0a
+size 323598
diff --git a/projections_check.xlsx b/projections_check.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..94856b80bf4a7c35275ae539d29bdbab81412c25
--- /dev/null
+++ b/projections_check.xlsx
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52c65e30c04a9a4cad3d1ee775d65ad26b9340ed880a62d468ef9b1f6071f2f5
+size 29713
diff --git a/rates_config.json b/rates_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..ade3711644792b40dc458d97b41d9f0918efe93b
--- /dev/null
+++ b/rates_config.json
@@ -0,0 +1,17 @@
+{
+ "decay_rates": {
+ "default": 0.98,
+ "suspended": 0.94,
+ "injured_decay": 0.94,
+ "rotational_risk": 0.94
+ },
+ "ramp_up_rates": {
+ "default": 2.0,
+ "injured": 8.0,
+ "suspended": 4.0,
+ "starter": 0.0,
+ "rotational_risk": 0.0
+ },
+ "RAMP_UP_PERIOD": 3,
+ "MINS_THRESHOLD": 35
+}
\ No newline at end of file
diff --git a/rename.json b/rename.json
new file mode 100644
index 0000000000000000000000000000000000000000..1672bda6897be03071cd050a8c987e4d54afd383
--- /dev/null
+++ b/rename.json
@@ -0,0 +1,204 @@
+{
+ "David Raya Martín": "David Raya",
+ "Pablo Felipe Pereira de Jesus": "Pablo",
+ "Amad Diallo": "Amad",
+ "Đorđe Petrović": "Djordje Petrovic",
+ "Alysson Edward Franco da Rocha dos Santos": "Alysson Edward",
+ "Junior Kroupi": "Junior Kroupi",
+ "Mateo Kovačić": "Mateo Kovacic",
+ "Saša Lukić": "Sasa Lukic",
+ "Tomáš Souček": "Tomas Soucek",
+ "Joško Gvardiol": "Josko Gvardiol",
+ "Mohamadou Kanté": "Mohamadou Kante",
+ "Álex Jiménez Sánchez": "Álex Jiménez",
+ "Alex Tóth": "Alex Toth",
+ "Veljko Milosavljević": "Veljko Milosavljevic",
+ "Mateus Gonçalo Espanha Fernandes": "Mateus Fernandes",
+ "Hwang Hee-chan": "Hee-Chan Hwang ",
+ "Mats Wieffer": "Mats Wieffer",
+ "Yéremy Pino Santos": "Yéremi Pino",
+ "Luis Eduardo Soares da Silva": "Cuiabano",
+ "Kevin Santos Lopes de Macedo": "Kevin",
+ "Florentino Ibrain Morris Luís": "Florentino",
+ "John Victor Maciel Furtado": "John Victor",
+ "Manuel Ugarte Ribeiro": "Manuel Ugarte",
+ "Douglas Luiz Soares de Paulo": "Douglas Luiz",
+ "Ben Gannon-Doak": "Ben Gannon Doak",
+ "Benjamin Šeško": "Benjamin Sesko",
+ "Dan Burn": "Daniel Burn",
+ "João Maria Lobo Alves Palhares Costa Palhinha Gonçalves": "Joao Palhinha",
+ "Diego León Blanco": "Diego León",
+ "Blondy Nna Noukeu": "Blondy Noukeu",
+ "Saša Kalajdžić": "Sasa Kalajdzic",
+ "Lucas Estella Perri": "Lucas Perri",
+ "Nico O’Reilly": "Nico O'Reilly",
+ "Josh King": "Joshua King",
+ "Jaydon Banel": "Jaydon Amauri Banel",
+ "Aarón Anselmino": "Aaron Anselmino",
+ "Kim Ji-soo": "Kim Jisoo",
+ "Paris Maghoma": "Edmond-Paris Maghoma",
+ "Joe Hodge": "Joseph Hodge",
+ "Joe Gomez": "Joseph Gomez",
+ "Manuel Benson Hedilazio": "Benson Manuel",
+ "Zépiqueno Redmond": "Zepiqueno Redmond",
+ "Ben Broggio": "Benjamin Broggio",
+ "Kepa Arrizabalaga Revuelta": "Kepa Arrizabalaga",
+ "Karl Hein": "Karl Jakob Hein",
+ "Emiliano Martínez Romero": "Emiliano Martínez",
+ "Norberto Murara Neto": "Neto",
+ "Callan McKenna": "Callan Mckenna",
+ "Robert Lynch Sánchez": "Robert Sánchez",
+ "Filip Jørgensen": "Filip Jörgensen",
+ "Gabriel Słonina": "Gabriel Slonina",
+ "Alisson": "Alisson Becker",
+ "Walter Benítez": "Walter Benitez",
+ "Altay Bayındır": "Altay Bayindir",
+ "Ederson Santana de Moraes": "Ederson",
+ "Stefan Ortega Moreno": "Stefan Ortega",
+ "Carlos Miguel dos Santos Pereira": "Carlos Miguel",
+ "José Malheiro de Sá": "José Sá",
+ "Gabriel dos Santos Magalhães": "Gabriel",
+ "Jurriën Timber": "Jurriën Timber",
+ "Benjamin White": "Ben White",
+ "Gabriel Martinelli Silva": "Gabriel Martinelli",
+ "Mikel Merino Zazón": "Mikel Merino",
+ "Fábio Ferreira Vieira": "Fábio Vieira",
+ "Martín Zubimendi Ibáñez": "Martín Zubimendi",
+ "Andrés García": "Andres Garcia",
+ "Gabriel Fernando de Jesus": "Gabriel Jesus",
+ "Ezri Konsa Ngoyo": "Ezri Konsa",
+ "Álex Moreno Lopera": "Álex Moreno",
+ "Lino da Cruz Sousa": "Lino Sousa",
+ "Emiliano Buendía Stati": "Emiliano Buendía",
+ "Victor Lindelöf": "Victor Nilsson Lindelöf",
+ "Jamaldeen Jimoh-Aloba": "Jamaldeen Jimoh",
+ "Lucas Pires Silva": "Lucas Pires",
+ "Darko Churlinov": "Darko Gyabi",
+ "Mike Trésor Ndayishimiye": "Mike Trésor",
+ "Marcos Senesi Barón": "Marcos Senesi",
+ "Julián Araujo Zúñiga": "Julián Araujo",
+ "Julio Soler Barreto": "Julio Soler",
+ "Luis Sinisterra Lucumí": "Luis Sinisterra",
+ "Francisco Evanilson de Lima Barbosa": "Evanilson",
+ "Mads Roerslev Rasmussen": "Mads Roerslev",
+ "Fábio Freitas Gouveia Carvalho": "Fábio Carvalho",
+ "Gustavo Nunes Fernandes Gomes": "Gustavo Nunes",
+ "Igor Thiago Nascimento Rodrigues": "Igor Thiago",
+ "Joel Veltman": "Joël Veltman",
+ "De Cuyper": "Maxim De Cuyper",
+ "Max Weiß": "Max Weiss",
+ "Václav Hladký": "Vaclav Hladky",
+ "Pervis Estupiñán Tenorio": "Pervis Estupiñán",
+ "Ferdi Kadıoğlu": "Ferdi Kadioglu",
+ "Igor Julio dos Santos de Paulo": "Igor Julio",
+ "Mitoma Kaoru": "Kaoru Mitoma",
+ "Julio Enciso Espínola": "Julio Enciso",
+ "Matt O'Riley": "Matthew O'Riley",
+ "Diego Gómez Amarilla": "Diego Gómez",
+ "Jeremy Sarmiento Morante": "Jeremy Sarmiento",
+ "Malick Yalcouyé": "Malick Yalcouye",
+ "Marc Cucurella Saseta": "Marc Cucurella",
+ "Levi Samuels Colwill": "Levi Colwill",
+ "Cheick Doucouré": "Cheick Oumar Doucouré",
+ "Benoît Badiashile Mukinayi": "Benoît Badiashile",
+ "Joshua Acheampong": "Josh Acheampong",
+ "Joe Willock": "Joseph Willock",
+ "Pedro Lomba Neto": "Pedro Neto",
+ "Estêvão Almeida de Oliveira Gonçalves": "Estêvão",
+ "Roméo Lavia": "Romeo Lavia",
+ "Jamie Bynoe-Gittens": "Jamie Gittens",
+ "Moisés Caicedo Corozo": "Moisés Caicedo",
+ "Andrey Nascimento dos Santos": "Andrey Santos",
+ "Dário Luís Essugo": "Dário Essugo",
+ "Kendry Páez Andrade": "Kendry Páez",
+ "Radu Drăgușin": "Radu Dragusin",
+ "João Pedro Junqueira de Jesus": "João Pedro",
+ "Pape Matar Sarr": "Pape Sarr",
+ "Marc Guiu Paz": "Marc Guiu",
+ "Daniel Muñoz Mejía": "Daniel Muñoz",
+ "Chadi Riad Dnanou": "Chadi Riad",
+ "Miodrag Pivaš": "Miodrag Pivas",
+ "Jefferson Lerma Solís": "Jefferson Lerma",
+ "Matheus França de Oliveira": "Matheus França",
+ "Zach Marsh": "Zachariah Marsh",
+ "Vitalii Mykolenko": "Vitaliy Mykolenko",
+ "Carlos Alcaraz Durán": "Carlos Alcaraz",
+ "Sékou Koné": "Sekou Koné",
+ "Norberto Bercique Gomes Betuncal": "Beto",
+ "Youssef Ramalho Chermiti": "Youssef Chermiti",
+ "Jorge Cuenca Barreno": "Jorge Cuenca",
+ "Adama Traoré Diarra": "Adama Traoré",
+ "Andreas Hoelgebaum Pereira": "Andreas Pereira",
+ "Raúl Jiménez Rodríguez": "Raul Jiménez",
+ "João Victor de Souza Menezes": "Souza",
+ "Rayan Vitor Simplício Rocha": "Rayan",
+ "Tino Livramento": "Valentino Livramento",
+ "Rodrigo Muniz Carvalho": "Rodrigo Muniz",
+ "Tanaka Ao": "Ao Tanaka",
+ "Mateo Joseph Fernández-Regatillo": "Mateo Joseph",
+ "Konstantinos Tsimikas": "Kostas Tsimikas",
+ "Luis Díaz Marulanda": "Luis Díaz",
+ "Endo Wataru": "Wataru Endo",
+ "Stefan Bajčetić Maquieira": "Stefan Bajcetic",
+ "Darwin Núñez Ribeiro": "Darwin Núñez",
+ "Rúben dos Santos Gato Alves Dias": "Rúben Dias",
+ "Vitor de Oliveira Nunes dos Reis": "Vitor Reis",
+ "Sávio Moreira de Oliveira": "Savinho",
+ "Bernardo Mota Veiga de Carvalho e Silva": "Bernardo Silva",
+ "Nikola Milenković": "Nikola Milenkovic",
+ "Nicolás Domínguez": "Nicolás Dominguez",
+ "Leo Fuhr Hjelde": "Leo Hjelde",
+ "Rodrigo 'Rodri' Hernandez Cascante": "Rodri",
+ "Nico González Iglesias": "Nico González",
+ "Diogo Dalot Teixeira": "Diogo Dalot",
+ "Bruno Borges Fernandes": "Bruno Fernandes",
+ "Matheus Santos Carneiro da Cunha": "Matheus Cunha",
+ "Dan Neil": "Daniel Neil",
+ "Alejandro Garnacho Ferreyra": "Alejandro Garnacho",
+ "Antony dos Santos": "Antony",
+ "Carlos Henrique Casimiro": "Casemiro",
+ "Chido Obi": "Chidozie Obi-Martin",
+ "Aji Alese": "Ajibola Alese",
+ "Bruno Guimarães Rodriguez Moura": "Bruno Guimarães",
+ "Joelinton Cássio Apolinário de Lira": "Joelinton",
+ "Antoñito Cordero Campillo": "Antonio Cordero",
+ "Murillo Costa dos Santos": "Murillo",
+ "David Mota Veiga Teixeira do Carmo": "David Carmo",
+ "Jair Paula da Cunha Filho": "Jair Cunha",
+ "Felipe Rodrigues da Silva": "Morato",
+ "João Pedro Ferreira da Silva": "Jota Silva",
+ "Igor Jesus Maciel da Cruz": "Igor Jesus",
+ "Jesurun Rak-Sakyi": "Jesurun Rak Sakyi",
+ "Marko Stamenić": "Marko Stamenic",
+ "Timothée Pembélé": "Timothee Pembele",
+ "Reinildo Mandava": "Reinildo",
+ "Ian Poveda-Ocampo": "Ian Poveda",
+ "Eliezer Mayenda Dossou": "Eliezer Mayenda",
+ "Luís Hemir Silva Semedo": "Luís Hemir",
+ "Nazarii Rusyn": "Nazariy Rusyn",
+ "Pedro Porro Sauceda": "Pedro Porro",
+ "Takai Kōta": "Kōta Takai",
+ "Bryan Gil Salvatierra": "Bryan Gil",
+ "Ollie Scarles": "Oliver Scarles",
+ "Eddie Nketiah": "Edward Nketiah",
+ "Dominic Solanke-Mitchell": "Dominic Solanke",
+ "Richarlison de Andrade": "Richarlison",
+ "El Hadji Malick Diouf": "Malick Diouf",
+ "Emerson Palmieri dos Santos": "Emerson Palmieri",
+ "Maximilian Kilman": "Max Kilman",
+ "Lucas Tolentino Coelho de Lima": "Lucas Paquetá",
+ "Edson Álvarez Velázquez": "Edson Álvarez",
+ "Luis Guilherme Lira dos Santos": "Luis Guilherme",
+ "Hugo Bueno López": "Hugo Bueno",
+ "Yerson Mosquera Valdelamar": "Yerson Mosquera",
+ "Rodrigo Martins Gomes": "Rodrigo Gomes",
+ "Santiago Ignacio Bueno": "Santiago Bueno",
+ "Bastien Meupiyou Menadjou": "Bastien Meupiyou",
+ "Pedro Cardoso de Lima": "Pedro Lima",
+ "André Trindade da Costa Neto": "André",
+ "Fer López González": "Fer López",
+ "João Victor Gomes da Silva": "João Gomes",
+ "Gonçalo Manuel Ganchinho Guedes": "Gonçalo Guedes",
+ "Enso González Medina": "Enso Gonzalez",
+ "Fábio Soares Silva": "Fábio Silva"
+}
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fb5b1323b1731b6c5615dbfb529cfae427b7dfd2
Binary files /dev/null and b/requirements.txt differ
diff --git a/solver.py b/solver.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a1b12d635c6d7fa0b9cdde6ea8a8846fea392dd
--- /dev/null
+++ b/solver.py
@@ -0,0 +1,607 @@
+import pulp
+
+
+def run_milp_model(data: dict):
+ print("Igniting Advanced Iterative MILP Engine (Original Solver Parity)...")
+
+ players = data["players"]
+ gws = data["gws"]
+ buy_prices = data["buy_prices"]
+ sell_prices = data["sell_prices"]
+ positions = data["positions"]
+ teams = data["teams"]
+ ev_matrix = data["ev_matrix"]
+ raw_ev_matrix = data.get("raw_ev_matrix", ev_matrix)
+ current_squad = data["current_squad"]
+ start_itb = data["itb"]
+ start_ft = data["ft"]
+
+ settings = data.get("settings", {})
+
+ # --- STRICT SINGLE SOURCE OF TRUTH ---
+ # Python no longer guesses. It extracts exactly what React tells it to.
+ time_limit_sec = int(settings.get("secs", settings.get("time_limit_sec")))
+ iterations = int(settings.get("iterations", 1))
+ iteration_diff = int(settings.get("iteration_diff", 1))
+ iteration_criteria = settings.get("iteration_criteria", "this_gw_transfer_in_out")
+ banned_ids = settings.get("banned_ids", [])
+ locked_ids = settings.get("locked_ids", [])
+
+ # Directly extracting required scalar values from the React payload
+ hit_cost = float(settings["hit_cost"])
+ max_ft = int(settings["max_ft"])
+ itb_value = float(settings["itb_value"])
+ vice_weight = float(settings.get("vcap_weight", settings["vice_weight"]))
+ max_per_team = int(settings["max_per_team"])
+ no_transfer_last_gws = int(settings["no_transfer_last_gws"])
+ itb_loss_per_transfer = float(settings["itb_loss_per_transfer"])
+ ft_use_penalty = float(settings["ft_use_penalty"])
+ decay_base = float(settings.get("decay_base", 1.0))
+
+ # --- FT STATE VALUATION ---
+ raw_ft_value = float(settings["ft_value"])
+ use_ftvl_flag = str(settings.get("use_ft_value_list", "false")).lower() in [
+ "true",
+ "1",
+ ]
+ raw_ftvl = settings.get("ft_value_list", {}) if use_ftvl_flag else {}
+
+ ft_states_list = list(range(max_ft + 1))
+ ft_state_value = {}
+ for s in ft_states_list:
+ val = float(raw_ftvl.get(str(s), raw_ft_value)) if raw_ftvl else raw_ft_value
+ ft_state_value[s] = ft_state_value.get(s - 1, 0.0) + val
+
+ # --- CHIP SETTINGS ---
+ use_wc = [int(g) for g in (settings.get("use_wc") or [])]
+ use_fh = [int(g) for g in (settings.get("use_fh") or [])]
+ use_bb = [int(g) for g in (settings.get("use_bb") or [])]
+ use_tc = [int(g) for g in (settings.get("use_tc") or [])]
+
+ # Bench weights (Strictly trusts the payload dictionary)
+ raw_bw = settings["bench_weights"]
+ bench_weights = {int(k): float(v) for k, v in raw_bw.items()}
+ gk_bench_w = bench_weights.get(0, 0.03)
+ of_bench_ws = [bench_weights.get(i, 0.0) for i in [1, 2, 3]]
+ avg_of_bench_w = sum(of_bench_ws) / len(of_bench_ws) if of_bench_ws else 0.05
+
+ chip_gws: dict[int, str] = {}
+ for g in use_wc:
+ if g in gws:
+ chip_gws[g] = "wc"
+ for g in use_fh:
+ if g in gws:
+ chip_gws[g] = "fh"
+ for g in use_bb:
+ if g in gws:
+ chip_gws[g] = "bb"
+ for g in use_tc:
+ if g in gws:
+ chip_gws[g] = "tc"
+
+ all_gws = [gws[0] - 1] + gws
+
+ # --- FREE HIT SQUAD REVERSION ---
+ effective_prev: dict[int, int] = {}
+ for w in gws:
+ prev_w = all_gws[all_gws.index(w) - 1]
+ if chip_gws.get(prev_w) == "fh":
+ fh_prev_idx = all_gws.index(prev_w) - 1
+ effective_prev[w] = all_gws[fh_prev_idx]
+ else:
+ effective_prev[w] = prev_w
+
+ prob = pulp.LpProblem("Luigis_Mansion_FPL_Solver", pulp.LpMaximize)
+
+ # --- DECISION VARIABLES ---
+ squad = pulp.LpVariable.dicts("squad", (players, all_gws), cat="Binary")
+ lineup = pulp.LpVariable.dicts("lineup", (players, gws), cat="Binary")
+ captain = pulp.LpVariable.dicts("captain", (players, gws), cat="Binary")
+ vice_captain = pulp.LpVariable.dicts("vice_captain", (players, gws), cat="Binary")
+ transfer_in = pulp.LpVariable.dicts("transfer_in", (players, gws), cat="Binary")
+ transfer_out = pulp.LpVariable.dicts("transfer_out", (players, gws), cat="Binary")
+ itb = pulp.LpVariable.dicts("itb", all_gws, lowBound=0, cat="Continuous")
+ fts = pulp.LpVariable.dicts(
+ "fts", all_gws, lowBound=1, upBound=max_ft, cat="Integer"
+ )
+ hits = pulp.LpVariable.dicts("hits", gws, lowBound=0, cat="Integer")
+
+ ft_below_lb = pulp.LpVariable.dicts("ft_below_lb", gws, cat="Binary")
+ ft_above_ub = pulp.LpVariable.dicts("ft_above_ub", gws, cat="Binary")
+ fts_state = pulp.LpVariable.dicts("fts_state", (gws, ft_states_list), cat="Binary")
+
+ daux = (
+ pulp.LpVariable.dicts("daux", (list(set(teams.values())), gws), cat="Binary")
+ if settings.get("double_defense_pick")
+ else None
+ )
+ gw_with_tr = (
+ pulp.LpVariable.dicts("gw_with_tr", gws, cat="Binary")
+ if settings.get("transfer_itb_buffer") is not None
+ else None
+ )
+
+ # --- FT STATE LINKING ---
+ for w in gws:
+ prev_w = all_gws[all_gws.index(w) - 1]
+ prob += fts[prev_w] == pulp.lpSum(s * fts_state[w][s] for s in ft_states_list)
+ prob += pulp.lpSum(fts_state[w][s] for s in ft_states_list) == 1
+
+ gw_ft_value = {
+ w: pulp.lpSum(ft_state_value[s] * fts_state[w][s] for s in ft_states_list)
+ for w in gws
+ }
+
+ gw_ft_gain = {}
+ for i, w in enumerate(gws):
+ if i == 0:
+ # MATCH solver_original.py EXACTLY: difference from 0 for the first gw
+ gw_ft_gain[w] = gw_ft_value[w] - 0.0
+ else:
+ prev_w = gws[i - 1]
+ gw_ft_gain[w] = gw_ft_value[w] - gw_ft_value[prev_w]
+
+ # --- OBJECTIVE FUNCTION (Decayed to match original) ---
+ obj_parts = []
+ for i, w in enumerate(gws):
+ # Apply decay strictly to Hits, ITB, and FT Gains so the solver respects the horizon timing
+ decay_factor = pow(decay_base, i)
+ chip = chip_gws.get(w)
+
+ for p in players:
+ # Player EVs are already pre-decayed by solver_engine.py
+ ev = ev_matrix[p].get(w, 0)
+
+ cap_extra = 2.0 if chip == "tc" else 1.0
+ obj_parts.append(ev * lineup[p][w])
+ obj_parts.append(ev * cap_extra * captain[p][w])
+ obj_parts.append(ev * vice_weight * vice_captain[p][w])
+
+ bw = (
+ 1.0
+ if chip == "bb"
+ else (gk_bench_w if positions[p] == "G" else avg_of_bench_w)
+ )
+ obj_parts.append(ev * bw * (squad[p][w] - lineup[p][w]))
+
+ obj_parts.append(itb[w] * itb_value * decay_factor)
+ obj_parts.append(gw_ft_gain[w] * decay_factor)
+ obj_parts.append(-hits[w] * hit_cost * decay_factor)
+
+ # FT-use penalty ONLY applied outside of Wildcard/Free Hit
+ if ft_use_penalty != 0 and chip not in ("wc", "fh"):
+ for p in players:
+ obj_parts.append(-transfer_in[p][w] * ft_use_penalty * decay_factor)
+
+ prob += pulp.lpSum(obj_parts), "Total_EV_Objective"
+
+ # --- ADVANCED HORIZON-LEVEL CONSTRAINTS ---
+ if settings.get("hit_limit") is not None:
+ prob += pulp.lpSum(hits[w] for w in gws) <= settings["hit_limit"]
+
+ if settings.get("future_transfer_limit") is not None and len(gws) > 1:
+ prob += (
+ pulp.lpSum(
+ transfer_in[p][w]
+ for p in players
+ for w in gws[1:]
+ if chip_gws.get(w) not in ("wc", "fh")
+ )
+ <= settings["future_transfer_limit"]
+ )
+
+ if settings.get("no_gk_rotation_after") is not None:
+ target_gw = int(settings["no_gk_rotation_after"])
+ if target_gw in gws:
+ for p in players:
+ if positions[p] == "G":
+ for w in gws:
+ if w > target_gw and chip_gws.get(w) != "fh":
+ prob += lineup[p][w] >= lineup[p][target_gw]
+
+ # --- INITIAL CONDITIONS ---
+ for p in players:
+ prob += squad[p][all_gws[0]] == (1 if p in current_squad else 0)
+ prob += itb[all_gws[0]] == start_itb
+ prob += fts[all_gws[0]] == start_ft
+
+ # --- USER BANS & LOCKS ---
+ for p in players:
+ if p in banned_ids:
+ for w in gws:
+ prob += squad[p][w] == 0
+ if p in locked_ids:
+ for w in gws:
+ prob += squad[p][w] == 1
+
+ # --- TARGETED CHIP/PRICE CONSTRAINTS ---
+ for gw in settings.get("no_chip_gws", []):
+ if gw in chip_gws:
+ raise Exception(
+ f"Contradiction: user tried to play chip in GW {gw} but also assigned it to no_chip_gws!"
+ )
+
+ if settings.get("pick_prices"):
+ for pos, val in settings["pick_prices"].items():
+ if not val or pos not in ("G", "D", "M", "F"):
+ continue
+ price_pts = [float(x) for x in val.split(",")]
+ value_dict = {i: price_pts.count(i) for i in set(price_pts)}
+ for key, count in value_dict.items():
+ target_players = [
+ p
+ for p in players
+ if positions[p] == pos
+ and buy_prices[p] >= key - 0.2
+ and buy_prices[p] <= key + 0.2
+ ]
+ for w in gws:
+ prob += pulp.lpSum(squad[p][w] for p in target_players) >= count
+
+ # --- PER-GW CONSTRAINTS ---
+ for w in gws:
+ prev_w = all_gws[all_gws.index(w) - 1]
+ eff_prev = effective_prev[w]
+ chip = chip_gws.get(w)
+
+ prob += pulp.lpSum(squad[p][w] for p in players) == 15
+ prob += pulp.lpSum(squad[p][w] for p in players if positions[p] == "G") == 2
+ prob += pulp.lpSum(squad[p][w] for p in players if positions[p] == "D") == 5
+ prob += pulp.lpSum(squad[p][w] for p in players if positions[p] == "M") == 5
+ prob += pulp.lpSum(squad[p][w] for p in players if positions[p] == "F") == 3
+
+ prob += pulp.lpSum(lineup[p][w] for p in players) == 11
+ prob += pulp.lpSum(lineup[p][w] for p in players if positions[p] == "G") == 1
+ prob += pulp.lpSum(lineup[p][w] for p in players if positions[p] == "D") >= 3
+ prob += pulp.lpSum(lineup[p][w] for p in players if positions[p] == "D") <= 5
+ prob += pulp.lpSum(lineup[p][w] for p in players if positions[p] == "M") >= 2
+ prob += pulp.lpSum(lineup[p][w] for p in players if positions[p] == "M") <= 5
+ prob += pulp.lpSum(lineup[p][w] for p in players if positions[p] == "F") >= 1
+ prob += pulp.lpSum(lineup[p][w] for p in players if positions[p] == "F") <= 3
+ prob += pulp.lpSum(captain[p][w] for p in players) == 1
+ prob += pulp.lpSum(vice_captain[p][w] for p in players) == 1
+
+ for p in players:
+ prob += lineup[p][w] <= squad[p][w]
+ prob += captain[p][w] <= lineup[p][w]
+ prob += vice_captain[p][w] <= lineup[p][w]
+ prob += captain[p][w] + vice_captain[p][w] <= 1
+ prob += (
+ squad[p][w]
+ == squad[p][eff_prev] + transfer_in[p][w] - transfer_out[p][w]
+ )
+
+ for t in set(teams.values()):
+ prob += (
+ pulp.lpSum(squad[p][w] for p in players if teams[p] == t)
+ <= max_per_team
+ )
+
+ if gws.index(w) >= len(gws) - no_transfer_last_gws and chip not in ("wc", "fh"):
+ prob += pulp.lpSum(transfer_in[p][w] for p in players) == 0
+
+ prob += (
+ itb[eff_prev]
+ + pulp.lpSum(transfer_out[p][w] * sell_prices[p] for p in players)
+ - pulp.lpSum(transfer_in[p][w] * buy_prices[p] for p in players)
+ - pulp.lpSum(transfer_in[p][w] * itb_loss_per_transfer for p in players)
+ == itb[w]
+ )
+
+ gw_transfers = pulp.lpSum(transfer_in[p][w] for p in players)
+
+ # FT / Hits Engine
+ if chip in ("wc", "fh"):
+ prob += hits[w] == 0
+ raw_gw_ft = fts[prev_w]
+ else:
+ prob += hits[w] >= gw_transfers - fts[prev_w]
+ raw_gw_ft = fts[prev_w] - gw_transfers + 1
+
+ m = 25
+ prob += raw_gw_ft <= 0 + m * (1 - ft_below_lb[w])
+ prob += raw_gw_ft >= 1 - m * ft_below_lb[w]
+
+ prob += raw_gw_ft >= (max_ft + 1) - m * (1 - ft_above_ub[w])
+ prob += raw_gw_ft <= max_ft + m * ft_above_ub[w]
+
+ prob += fts[w] <= 1 + m * (1 - ft_below_lb[w])
+ prob += fts[w] >= 1 - m * (1 - ft_below_lb[w])
+
+ prob += fts[w] <= max_ft + m * (1 - ft_above_ub[w])
+ prob += fts[w] >= max_ft - m * (1 - ft_above_ub[w])
+
+ prob += fts[w] - raw_gw_ft <= m * ft_below_lb[w] + m * ft_above_ub[w]
+ prob += raw_gw_ft - fts[w] <= m * ft_below_lb[w] + m * ft_above_ub[w]
+
+ # --- ADVANCED GW-LEVEL CONSTRAINTS ---
+ for pid, tgw in settings.get("banned_next_gw", []):
+ if pid in players and (tgw == w or tgw is None):
+ prob += squad[pid][w] == 0
+
+ for pid, tgw in settings.get("locked_next_gw", []):
+ if pid in players and (tgw == w or tgw is None):
+ prob += squad[pid][w] == 1
+
+ for bt in settings.get("booked_transfers", []):
+ if bt.get("gw") == w:
+ if bt.get("transfer_in") in players:
+ prob += transfer_in[bt["transfer_in"]][w] == 1
+ if bt.get("transfer_out") in players:
+ prob += transfer_out[bt["transfer_out"]][w] == 1
+
+ if settings.get("only_booked_transfers") and w == gws[0]:
+ forced_ins = [
+ bt["transfer_in"]
+ for bt in settings.get("booked_transfers", [])
+ if bt.get("gw") == w and "transfer_in" in bt
+ ]
+ forced_outs = [
+ bt["transfer_out"]
+ for bt in settings.get("booked_transfers", [])
+ if bt.get("gw") == w and "transfer_out" in bt
+ ]
+ for p in players:
+ prob += transfer_in[p][w] == (1 if p in forced_ins else 0)
+ prob += transfer_out[p][w] == (1 if p in forced_outs else 0)
+
+ if settings.get("num_transfers") is not None and w == gws[0]:
+ prob += gw_transfers == int(settings["num_transfers"])
+
+ if (
+ settings.get("no_future_transfer")
+ and w > gws[0]
+ and chip not in ("wc", "fh")
+ ):
+ prob += gw_transfers == 0
+
+ if settings.get("weekly_hit_limit") is not None:
+ prob += hits[w] <= int(settings["weekly_hit_limit"])
+
+ if w in settings.get("no_transfer_gws", []):
+ prob += gw_transfers == 0
+
+ if (
+ settings.get("no_transfer_by_position")
+ and w > gws[0]
+ and chip not in ("wc", "fh")
+ ):
+ prob += (
+ pulp.lpSum(
+ transfer_in[p][w]
+ for p in players
+ if positions[p] in settings["no_transfer_by_position"]
+ )
+ == 0
+ )
+
+ mdpt = settings.get("max_defenders_per_team", 3)
+ if mdpt < 3:
+ for t in set(teams.values()):
+ prob += (
+ pulp.lpSum(
+ squad[p][w]
+ for p in players
+ if teams[p] == t and positions[p] in ("G", "D")
+ )
+ <= mdpt
+ )
+
+ if settings.get("double_defense_pick") and daux is not None:
+ for t in set(teams.values()):
+ team_defs = pulp.lpSum(
+ lineup[p][w]
+ for p in players
+ if teams[p] == t and positions[p] in ("G", "D")
+ )
+ prob += team_defs <= 3 * daux[t][w]
+ prob += team_defs >= 2 - 3 * (1 - daux[t][w])
+
+ if settings.get("transfer_itb_buffer") is not None and gw_with_tr is not None:
+ prob += 15 * gw_with_tr[w] >= gw_transfers
+ prob += gw_with_tr[w] <= gw_transfers
+ prob += itb[w] >= settings["transfer_itb_buffer"] * gw_with_tr[w]
+
+ for gw, ft_min in settings.get("force_ft_state_lb", []):
+ if w == gw:
+ prob += fts[w] >= ft_min
+ for gw, ft_max in settings.get("force_ft_state_ub", []):
+ if w == gw:
+ prob += fts[w] <= ft_max
+
+ if settings.get("no_trs_except_wc") and chip != "wc":
+ prob += gw_transfers == 0
+
+ # --- ITERATION LOOP ---
+ solutions = []
+ for i in range(iterations):
+ print(f"Solving Iteration {i + 1}...")
+
+ # THE FIX: Boot up the HiGHS engine instead of CBC
+ try:
+ solver = pulp.getSolver("HiGHS", msg=False, timeLimit=time_limit_sec)
+ except pulp.PulpSolverError:
+ print("HiGHS not found! Falling back to CBC...")
+ solver = pulp.PULP_CBC_CMD(msg=False, timeLimit=time_limit_sec)
+
+ prob.solve(solver)
+
+ if pulp.LpStatus[prob.status] != "Optimal":
+ if i == 0:
+ raise Exception(
+ "Solver could not find an optimal solution! Check budget, bans, or locks."
+ )
+ else:
+ print(f"No more valid alternate paths found after {i} iterations.")
+ break
+
+ plan = []
+ pure_ev = 0.0
+ active_transfers = []
+
+ objective_score = None
+ try:
+ objective_score = round(float(pulp.value(prob.objective)), 4)
+ except (TypeError, ValueError):
+ objective_score = None
+
+ for w in gws:
+ prev_w = all_gws[all_gws.index(w) - 1]
+ chip = chip_gws.get(w)
+
+ # THE FIX 1: Safely extract binary variables using > 0.5 to prevent MILP floating-point drops
+ t_in_raw = [
+ p
+ for p in players
+ if transfer_in[p][w].varValue is not None
+ and transfer_in[p][w].varValue > 0.5
+ ]
+ t_out_raw = [
+ p
+ for p in players
+ if transfer_out[p][w].varValue is not None
+ and transfer_out[p][w].varValue > 0.5
+ ]
+
+ t_in = [p for p in t_in_raw if p not in t_out_raw]
+ t_out = [p for p in t_out_raw if p not in t_in_raw]
+
+ _pos_order = {"G": 0, "D": 1, "M": 2, "F": 3}
+ t_in.sort(key=lambda x: _pos_order.get(positions.get(x, "M"), 2))
+ t_out.sort(key=lambda x: _pos_order.get(positions.get(x, "M"), 2))
+
+ gw_lineup = [
+ p
+ for p in players
+ if lineup[p][w].varValue is not None and lineup[p][w].varValue > 0.5
+ ]
+ gw_bench_raw = [
+ p
+ for p in players
+ if squad[p][w].varValue is not None
+ and squad[p][w].varValue > 0.5
+ and (lineup[p][w].varValue is None or lineup[p][w].varValue < 0.5)
+ ]
+
+ # Safe extractions with fallbacks so indexing never crashes the loop
+ gw_cap_list = [
+ p
+ for p in players
+ if captain[p][w].varValue is not None and captain[p][w].varValue > 0.5
+ ]
+ gw_cap = (
+ gw_cap_list[0]
+ if gw_cap_list
+ else (gw_lineup[0] if gw_lineup else players[0])
+ )
+
+ gw_vice_list = [
+ p
+ for p in players
+ if vice_captain[p][w].varValue is not None
+ and vice_captain[p][w].varValue > 0.5
+ ]
+ gw_vice = (
+ gw_vice_list[0]
+ if gw_vice_list
+ else (gw_lineup[-1] if gw_lineup else players[-1])
+ )
+
+ gw_hits = int(round(hits[w].varValue or 0))
+
+ ft_at_start = int(round(fts[prev_w].varValue or 0))
+ transfers_made = len(t_in)
+ fts_free_used = min(transfers_made, ft_at_start)
+
+ gks_b = [p for p in gw_bench_raw if positions.get(p, "M") == "G"]
+ rest_b = sorted(
+ [p for p in gw_bench_raw if positions.get(p, "M") != "G"],
+ key=lambda x: raw_ev_matrix[x].get(w, 0),
+ reverse=True,
+ )
+ gw_bench_sorted = (gks_b + rest_b) if gks_b else rest_b
+
+ cap_mult = 3 if chip == "tc" else 2
+ gw_pure_ev = sum(
+ raw_ev_matrix[p].get(w, 0) * (cap_mult if p == gw_cap else 1)
+ for p in gw_lineup
+ )
+
+ if chip == "bb":
+ gw_pure_ev += sum(raw_ev_matrix[p].get(w, 0) for p in gw_bench_sorted)
+ else:
+ # THE FIX 2: Perfectly mimic React's horizonEV fractional bench math
+ of_bench_ws = [0.17, 0.05, 0.02]
+ of_idx = 0
+ for p in gw_bench_sorted:
+ if positions.get(p, "M") == "G":
+ gw_pure_ev += raw_ev_matrix[p].get(w, 0) * 0.04
+ else:
+ bw = of_bench_ws[of_idx] if of_idx < len(of_bench_ws) else 0.02
+ gw_pure_ev += raw_ev_matrix[p].get(w, 0) * bw
+ of_idx += 1
+
+ gw_pure_ev -= gw_hits * hit_cost
+ pure_ev += gw_pure_ev
+
+ # Only track transfers for the targeted GW based on the UI criteria
+ if "this_gw" in iteration_criteria and w == gws[0]:
+ if "in" in iteration_criteria:
+ for p in t_in:
+ active_transfers.append(transfer_in[p][w])
+ if "out" in iteration_criteria:
+ for p in t_out:
+ active_transfers.append(transfer_out[p][w])
+ elif "this_gw" not in iteration_criteria:
+ # Fallback: track all horizon transfers if criteria is empty or generic
+ for p in t_in:
+ active_transfers.append(transfer_in[p][w])
+ for p in t_out:
+ active_transfers.append(transfer_out[p][w])
+
+ plan.append(
+ {
+ "gw": w,
+ "chip": chip,
+ "transfers_in": t_in,
+ "transfers_out": t_out,
+ "lineup": gw_lineup,
+ "bench": gw_bench_sorted,
+ "captain": gw_cap,
+ "vice_captain": gw_vice,
+ "hits": gw_hits,
+ "itb": round(itb[w].varValue, 1),
+ "fts_remaining": int(fts[w].varValue),
+ "ft_at_start": ft_at_start,
+ "transfers_made": transfers_made,
+ "fts_free_used": fts_free_used,
+ }
+ )
+
+ solutions.append(
+ {
+ "id": i + 1,
+ "ev": round(pure_ev, 2),
+ "objective_score": objective_score,
+ "plan": plan,
+ "chips_used": chip_gws,
+ "horizon_gws": gws,
+ }
+ )
+
+ if len(active_transfers) > 0:
+ prob += (
+ pulp.lpSum(active_transfers) <= len(active_transfers) - iteration_diff
+ )
+ else:
+ prob += pulp.lpSum(transfer_in[p][w] for p in players for w in gws) >= 1
+
+ def sort_key(s):
+ obj = s.get("objective_score")
+ ev = s.get("ev") or 0
+ if obj is None:
+ return (-float(ev), -float(ev))
+ return (-float(obj), -float(ev))
+
+ solutions.sort(key=sort_key)
+ return {"status": "success", "solutions": solutions}
diff --git a/solver_engine.py b/solver_engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..d22161c82f4709f3d1e048fa6542caf95462392b
--- /dev/null
+++ b/solver_engine.py
@@ -0,0 +1,185 @@
+from typing import Any
+
+
+def _norm_id_list(raw) -> list[int]:
+ if not raw:
+ return []
+ out = []
+ for x in raw:
+ if isinstance(x, dict) and "id" in x:
+ out.append(int(x["id"]))
+ else:
+ out.append(int(x))
+ return out
+
+
+def _norm_gw_list(raw) -> list[int]:
+ """Normalise a chip GW list to a list of ints, handling None gracefully."""
+ if not raw:
+ return []
+ return [int(g) for g in raw if g is not None]
+
+
+def prep_solver_data(payload_data: dict):
+ """
+ Translates the React JSON payload into the exact mathematical dictionaries
+ the MILP engine requires, including chips and advanced constraints.
+ """
+ print("Prepping data for the MILP Engine...")
+
+ horizon_gws = [int(g) for g in payload_data["horizon_gws"]]
+ raw_squad = payload_data["current_squad_ids"]
+ current_squad_ids = [
+ int(pid)
+ for pid in raw_squad
+ if isinstance(pid, (int, float)) or str(pid).isdigit()
+ ]
+
+ settings_payload: dict[str, Any] = dict(payload_data.get("settings") or {})
+ comp_payload = dict(payload_data.get("comprehensive_settings") or {})
+
+ # Start with an empty dictionary.
+ # Python no longer guesses defaults. It completely trusts the React payload.
+ settings = {}
+
+ # 1. Apply basic settings
+ settings.update({k: v for k, v in settings_payload.items() if v not in (None, "")})
+
+ # 2. Apply comprehensive settings (Filters out None AND empty strings from UI)
+ settings.update({k: v for k, v in comp_payload.items() if v not in (None, "")})
+
+ # --- BAN / LOCK ---
+ banned_ids = _norm_id_list(settings.get("banned") or settings.get("banned_ids"))
+ locked_ids = _norm_id_list(settings.get("locked") or settings.get("locked_ids"))
+ settings["banned_ids"] = banned_ids
+ settings["locked_ids"] = locked_ids
+
+ # --- SCALAR SETTINGS ---
+ settings["iterations"] = max(
+ 1,
+ min(5, int(settings.get("iterations", settings.get("num_iterations", 1)))),
+ )
+ settings["iteration_diff"] = int(settings.get("iteration_diff", 1))
+ settings["iteration_criteria"] = settings.get(
+ "iteration_criteria", "this_gw_transfer_in_out"
+ )
+ settings["hit_cost"] = int(settings.get("hit_cost", 4))
+ settings["max_ft"] = int(settings.get("max_ft", 5))
+ settings["itb_value"] = float(settings.get("itb_value", 0.08))
+ settings["time_limit_sec"] = int(settings.get("time_limit_sec", 3000))
+ settings["vice_weight"] = float(settings.get("vice_weight", 0.05))
+ settings["max_per_team"] = int(settings.get("max_per_team", 3))
+ settings["no_transfer_last_gws"] = int(settings.get("no_transfer_last_gws", 0))
+ settings["itb_loss_per_transfer"] = float(settings.get("itb_loss_per_transfer", 0))
+ settings["ft_value"] = float(
+ settings.get("ft_value_base", settings.get("ft_value", 0)) or 0
+ )
+ settings["ft_use_penalty"] = float(settings.get("ft_use_penalty", 0) or 0)
+ settings["future_transfer_limit"] = settings.get("future_transfer_limit")
+ if settings["future_transfer_limit"] is not None:
+ settings["future_transfer_limit"] = int(settings["future_transfer_limit"])
+ settings["hit_limit"] = settings.get("hit_limit")
+ if settings["hit_limit"] is not None:
+ settings["hit_limit"] = int(settings["hit_limit"])
+ settings["weekly_hit_limit"] = settings.get("weekly_hit_limit")
+ if settings["weekly_hit_limit"] is not None:
+ settings["weekly_hit_limit"] = int(settings["weekly_hit_limit"])
+ settings["no_transfer_gws"] = _norm_gw_list(settings.get("no_transfer_gws"))
+ settings["no_transfer_by_position"] = settings.get("no_transfer_by_position") or []
+ settings["no_trs_except_wc"] = bool(settings.get("no_trs_except_wc", False))
+ settings["max_defenders_per_team"] = int(settings.get("max_defenders_per_team", 3))
+ settings["double_defense_pick"] = bool(settings.get("double_defense_pick", False))
+ settings["transfer_itb_buffer"] = settings.get("transfer_itb_buffer")
+ if settings["transfer_itb_buffer"] is not None:
+ settings["transfer_itb_buffer"] = float(settings["transfer_itb_buffer"])
+ settings["no_gk_rotation_after"] = settings.get("no_gk_rotation_after")
+ settings["no_opposing_play"] = settings.get("no_opposing_play", False)
+ settings["opposing_play_group"] = settings.get("opposing_play_group", "all")
+ settings["opposing_play_penalty"] = float(
+ settings.get("opposing_play_penalty", 0.5)
+ )
+ settings["force_ft_state_lb"] = settings.get("force_ft_state_lb") or []
+ settings["force_ft_state_ub"] = settings.get("force_ft_state_ub") or []
+ settings["no_chip_gws"] = _norm_gw_list(settings.get("no_chip_gws"))
+
+ # Parse gw-specific lock/bans
+ def norm_temporal_list(raw):
+ if not raw:
+ return []
+ out = []
+ for x in raw:
+ if isinstance(x, list) and len(x) == 2:
+ out.append((int(x[0]), int(x[1])))
+ else:
+ out.append((int(x), None))
+ return out
+
+ settings["banned_next_gw"] = norm_temporal_list(settings.get("banned_next_gw"))
+ settings["locked_next_gw"] = norm_temporal_list(settings.get("locked_next_gw"))
+ settings["booked_transfers"] = settings.get("booked_transfers") or []
+ settings["only_booked_transfers"] = bool(
+ settings.get("only_booked_transfers", False)
+ )
+ settings["no_future_transfer"] = bool(settings.get("no_future_transfer", False))
+ settings["num_transfers"] = settings.get("num_transfers")
+ settings["pick_prices"] = settings.get("pick_prices", {})
+
+ # --- CHIP GW LISTS ---
+ settings["use_wc"] = _norm_gw_list(settings.get("use_wc"))
+ settings["use_fh"] = _norm_gw_list(settings.get("use_fh"))
+ settings["use_bb"] = _norm_gw_list(settings.get("use_bb"))
+ settings["use_tc"] = _norm_gw_list(settings.get("use_tc"))
+
+ # --- BENCH WEIGHTS (dict with string keys "0"-"3") ---
+ raw_bw = settings.get("bench_weights")
+ if raw_bw and isinstance(raw_bw, dict):
+ settings["bench_weights"] = {str(k): float(v) for k, v in raw_bw.items()}
+ else:
+ settings["bench_weights"] = {"0": 0.03, "1": 0.18, "2": 0.06, "3": 0.002}
+
+ # --- FT VALUE LIST (dict with string keys "2"-"5") ---
+ raw_ftvl = settings.get("ft_value_list")
+ if raw_ftvl and isinstance(raw_ftvl, dict):
+ settings["ft_value_list"] = {str(k): float(v) for k, v in raw_ftvl.items()}
+ else:
+ settings["ft_value_list"] = {}
+
+ # --- DECAY ---
+ decay = float(settings.get("decay_base", settings.get("decay", 1.0)) or 1.0)
+
+ # --- BUILD PLAYER DICTS ---
+ buy_prices: dict[int, float] = {}
+ sell_prices: dict[int, float] = {}
+ positions: dict[int, str] = {}
+ teams: dict[int, str] = {}
+ ev_matrix: dict[int, dict[int, float]] = {}
+ raw_ev_matrix: dict[int, dict[int, float]] = {}
+
+ for idx, gw in enumerate(horizon_gws):
+ decay_factor = decay**idx if decay != 1.0 else 1.0
+ for p in payload_data["market_players"]:
+ pid = int(p["id"])
+ if pid not in buy_prices:
+ positions[pid] = p["pos"]
+ teams[pid] = p["team"]
+ buy_prices[pid] = float(p["now_cost"])
+ sell_prices[pid] = float(p.get("sell_price", p["now_cost"]))
+ ev_matrix[pid] = {}
+ raw_ev_matrix[pid] = {}
+ raw_ev = p["evs"].get(gw, p["evs"].get(str(gw), 0))
+ ev_matrix[pid][gw] = float(raw_ev) * decay_factor
+ raw_ev_matrix[pid][gw] = float(raw_ev)
+
+ return {
+ "players": list(buy_prices.keys()),
+ "gws": horizon_gws,
+ "buy_prices": buy_prices,
+ "sell_prices": sell_prices,
+ "positions": positions,
+ "teams": teams,
+ "ev_matrix": ev_matrix,
+ "current_squad": current_squad_ids,
+ "itb": float(payload_data["in_the_bank"]),
+ "ft": int(payload_data["free_transfers"]),
+ "settings": settings,
+ }
diff --git a/statistical_weighted_baselines.csv b/statistical_weighted_baselines.csv
new file mode 100644
index 0000000000000000000000000000000000000000..b4328a97672dc2ce795736eb87b7aaf05a0f4d22
--- /dev/null
+++ b/statistical_weighted_baselines.csv
@@ -0,0 +1,437 @@
+player_name,baseline_xMins,baseline_xG_p90,baseline_xA_p90,baseline_CBIT_p90,baseline_CBITR_p90,baseline_yc_p90,baseline_rc_p90,baseline_Neutral_BPS_p90,baseline_Def_BPS_p90,baseline_Mid_BPS_p90,baseline_Fwd_BPS_p90,baseline_bps_floor_p90
+James Milner,39.6714,0.0613,0.0664,3.518,6.9378,0.212,0.0,5.7718,5.7718,5.7718,5.7718,2.7718
+Séamus Coleman,57.3963,0.0055,0.0786,5.6685,9.7906,0.0141,0.0,8.9059,8.9059,8.9059,8.9059,5.9059
+Ashley Barnes,21.6698,0.1182,0.0141,1.3284,3.1267,0.1613,0.0,1.732,1.732,1.732,1.732,-1.268
+Danny Welbeck,62.1536,0.3936,0.0611,2.6474,4.5537,0.2021,0.0,7.302,7.302,7.302,7.302,1.302
+Jordan Henderson,63.3945,0.0225,0.1382,3.7085,8.0825,0.1727,0.0,9.7514,9.7514,9.7514,9.7514,3.7514
+Nathaniel Clyne,58.9565,0.0532,0.084,4.7175,6.8736,0.078,0.0,6.2698,6.2698,6.2698,6.2698,3.2698
+Kyle Walker,84.584,0.0066,0.0587,5.3085,9.8583,0.2381,0.0,9.6246,9.6246,9.6246,9.6246,3.6246
+Adam Smith,47.3125,0.0085,0.0298,4.8414,7.5102,0.2777,0.0,5.4291,5.4291,5.4291,5.4291,2.4291
+Pascal Groß,71.4129,0.0866,0.2516,3.9695,8.0327,0.1435,0.0008,11.74,11.74,11.74,11.74,5.74
+Chris Wood,69.913,0.444,0.0275,1.1135,2.4636,0.0068,0.0,6.2547,6.2547,6.2547,6.2547,0.2547
+Idrissa Gana Gueye,83.974,0.0613,0.0509,5.3431,10.7496,0.1603,0.0329,10.4409,10.4409,10.4409,10.4409,4.4409
+Tom Cairney,27.1217,0.1147,0.075,2.4975,7.8839,0.3763,0.0404,6.7132,6.7132,6.7132,6.7132,3.7132
+Callum Wilson,38.9696,0.428,0.0288,1.3382,3.3843,0.0261,0.0,2.9714,2.9714,2.9714,2.9714,-0.0286
+Daniel Burn,80.3214,0.033,0.0203,8.3726,11.4704,0.3772,0.0,9.4923,9.4923,9.4923,9.4923,3.4923
+Fabian Schär,70.5607,0.0891,0.0449,7.9447,11.6652,0.1325,0.0069,10.1465,10.1465,10.1465,10.1465,4.1465
+Kieran Trippier,77.4041,0.0074,0.1299,5.1416,9.3718,0.1598,0.0,12.1454,12.1454,12.1454,12.1454,6.1454
+Lewis Dunk,87.7794,0.0429,0.0274,6.2588,10.7112,0.3055,0.0023,9.9572,9.9572,9.9572,9.9572,3.9572
+Wataru Endo,19.0795,0.0082,0.0259,3.2931,5.2888,0.0224,0.0,4.4307,4.4307,4.4307,4.4307,1.4307
+Granit Xhaka,84.6314,0.0314,0.1113,5.0263,10.2763,0.1623,0.0,10.3586,10.3586,10.3586,10.3586,4.3586
+Casemiro,72.5137,0.1724,0.1172,7.2079,12.5625,0.3861,0.002,11.0407,11.0407,11.0407,11.0407,5.0407
+Virgil van Dijk,90.0,0.0795,0.0337,8.4305,11.1223,0.1263,0.0021,10.804,10.804,10.804,10.804,4.804
+Lucas Digne,61.7184,0.0358,0.1357,5.8598,9.3683,0.1455,0.0,11.7889,11.7889,11.7889,11.7889,5.7889
+Ross Barkley,28.1208,0.1515,0.184,4.767,9.9865,0.0909,0.0,8.3527,8.3527,8.3527,8.3527,5.3527
+Mateo Kovacic,68.4976,0.0705,0.1114,4.602,8.8711,0.2021,0.0274,11.6324,11.6324,11.6324,11.6324,5.6324
+Matt Doherty,70.5783,0.0194,0.0314,5.5553,8.7791,0.3211,0.0,8.8949,8.8949,8.8949,8.8949,2.8949
+James Tarkowski,89.8182,0.0684,0.051,9.1775,11.9313,0.1796,0.0,11.0154,11.0154,11.0154,11.0154,5.0154
+Willy Boly,70.8854,0.074,0.0392,8.6866,13.4641,0.1853,0.0,12.9516,12.9516,12.9516,12.9516,6.9516
+Harry Maguire,66.7005,0.0713,0.0166,7.2094,10.7458,0.249,0.0506,9.5376,9.5376,9.5376,9.5376,3.5376
+Victor Nilsson Lindelöf,47.1313,0.0058,0.0088,4.885,7.4236,0.0124,0.0,6.0633,6.0633,6.0633,6.0633,3.0633
+Emil Krafth,31.185,0.008,0.0198,2.9578,5.4403,0.2968,0.0,5.3565,5.3565,5.3565,5.3565,2.3565
+John Stones,50.3134,0.0138,0.0203,3.5864,7.3437,0.0527,0.0,6.4839,6.4839,6.4839,6.4839,3.4839
+Christian Nørgaard,82.9266,0.1294,0.053,6.3074,12.6303,0.2601,0.0231,12.0969,12.0969,12.0969,12.0969,6.0969
+Ben Davies,76.3555,0.0711,0.0427,6.6989,9.8846,0.2962,0.0,10.5317,10.5317,10.5317,10.5317,4.5317
+James Ward-Prowse,65.6126,0.0427,0.1546,3.8792,7.2895,0.1521,0.0,11.7213,11.7213,11.7213,11.7213,5.7213
+Michael Keane,78.5698,0.0813,0.0067,9.3238,12.4687,0.127,0.0285,11.1349,11.1349,11.1349,11.1349,5.1349
+Raul Jiménez,66.1636,0.4172,0.0495,3.6303,6.032,0.1953,0.0048,6.4041,6.4041,6.4041,6.4041,0.4041
+Mohamed Salah,83.5283,0.3841,0.1955,1.7046,4.5425,0.0468,0.0,8.3554,8.3554,8.3554,8.3554,2.3554
+Will Hughes,50.0785,0.0613,0.1028,4.6142,8.7434,0.4291,0.0,5.8214,5.8214,5.8214,5.8214,2.8214
+Bertrand Traoré,53.9168,0.1412,0.0713,2.6317,5.2078,0.1344,0.0,5.7778,5.7778,5.7778,5.7778,2.7778
+Adam Webster,65.0944,0.0332,0.0242,6.582,10.604,0.0951,0.0,10.3366,10.3366,10.3366,10.3366,4.3366
+Joël Veltman,49.134,0.0764,0.0275,7.5607,11.1191,0.3037,0.0,7.3205,7.3205,7.3205,7.3205,4.3205
+Jack Grealish,75.5761,0.1228,0.2028,2.9445,7.2046,0.3559,0.0,10.6709,10.6709,10.6709,10.6709,4.6709
+Leandro Trossard,65.1074,0.2545,0.149,3.1624,6.7663,0.0767,0.0,9.3124,9.3124,9.3124,9.3124,3.3124
+John McGinn,71.4173,0.1195,0.1144,2.578,6.3241,0.1742,0.0003,8.3007,8.3007,8.3007,8.3007,2.3007
+Andrew Robertson,44.9528,0.044,0.1382,4.5253,8.2566,0.0351,0.0081,8.7264,8.7264,8.7264,8.7264,5.7264
+Luke Shaw,80.1451,0.0144,0.0849,4.9434,7.966,0.2004,0.0,8.6246,8.6246,8.6246,8.6246,2.6246
+Sam Byram,41.7403,0.058,0.0838,6.1084,10.1179,0.2161,0.0,5.1704,5.1704,5.1704,5.1704,2.1704
+Solly March,80.0836,0.3138,0.1364,5.0018,10.0345,0.0282,0.0,13.5614,13.5614,13.5614,13.5614,7.5614
+Nathan Aké,39.2062,0.0467,0.0534,5.1295,7.5916,0.1343,0.0,6.2377,6.2377,6.2377,6.2377,3.2377
+Tyrone Mings,74.8588,0.0851,0.0295,6.7748,9.6637,0.0329,0.0,10.0149,10.0149,10.0149,10.0149,4.0149
+Bruno Fernandes,86.6398,0.2737,0.3544,4.3505,9.4371,0.1269,0.0076,13.7658,13.7658,13.7658,13.7658,7.7658
+Ryan Christie,39.2327,0.1586,0.0814,5.6652,11.1537,0.3358,0.0,8.1985,8.1985,8.1985,8.1985,5.1985
+Enes Ünal,20.0751,0.3639,0.0478,2.1762,5.2773,0.294,0.0,2.3952,2.3952,2.3952,2.3952,-0.6048
+Timothy Castagne,55.0163,0.0558,0.0434,7.096,9.9304,0.1753,0.0,7.7746,7.7746,7.7746,7.7746,4.7746
+Youri Tielemans,74.8502,0.0659,0.1635,4.5134,8.8142,0.0234,0.0,10.4267,10.4267,10.4267,10.4267,4.4267
+Jefferson Lerma,54.2134,0.0575,0.0614,6.0078,10.74,0.3623,0.0,6.8811,6.8811,6.8811,6.8811,3.8811
+Kenny Tete,81.4565,0.0556,0.0612,8.2041,12.2687,0.1494,0.0,10.4875,10.4875,10.4875,10.4875,4.4875
+Luke O'Nien,86.9746,0.0531,0.0321,6.0196,10.0835,0.2469,0.0021,9.0739,9.0739,9.0739,9.0739,3.0739
+Connor Roberts,82.5452,0.0492,0.0838,3.6919,6.5497,0.1638,0.002,8.9503,8.9503,8.9503,8.9503,2.9503
+Bernardo Silva,75.8748,0.0787,0.1446,3.2829,7.2889,0.2977,0.0,9.4714,9.4714,9.4714,9.4714,3.4714
+James Maddison,60.9645,0.2712,0.2376,2.7141,5.5842,0.228,0.0,11.4599,11.4599,11.4599,11.4599,5.4599
+Adama Traoré,20.2039,0.0836,0.0622,1.2972,3.5844,0.0289,0.0,4.6235,4.6235,4.6235,4.6235,1.6235
+Harry Wilson,74.2824,0.2016,0.1416,3.6154,6.6863,0.1962,0.0,11.472,11.472,11.472,11.472,5.472
+Harrison Reed,52.776,0.0323,0.087,4.1656,8.7985,0.3522,0.0,6.8598,6.8598,6.8598,6.8598,3.8598
+Joachim Andersen,88.3484,0.0449,0.0483,9.4548,13.4665,0.2456,0.0076,11.2911,11.2911,11.2911,11.2911,5.2911
+Adam Armstrong,71.2089,0.3795,0.0821,2.1203,3.7849,0.1738,0.0,6.7006,6.7006,6.7006,6.7006,0.7006
+Jacob Murphy,50.5381,0.217,0.1878,2.9053,6.0014,0.0868,0.0,8.1246,8.1246,8.1246,8.1246,5.1246
+Josh Laurent,56.9545,0.0591,0.0513,5.099,8.6116,0.3508,0.0502,4.46,4.46,4.46,4.46,1.46
+Jarrod Bowen,89.3527,0.2134,0.1469,3.5336,7.5841,0.0945,0.0,9.9311,9.9311,9.9311,9.9311,3.9311
+João Palhinha,64.616,0.0731,0.0347,7.5809,10.9219,0.313,0.0302,8.0653,8.0653,8.0653,8.0653,2.0653
+Tomás Soucek,59.1118,0.2141,0.0259,5.8662,8.4173,0.1439,0.038,5.3244,5.3244,5.3244,5.3244,2.3244
+Martin Ødegaard,56.9913,0.115,0.2255,2.594,6.4656,0.034,0.0,8.0491,8.0491,8.0491,8.0491,5.0491
+Joelinton,72.0082,0.1271,0.0651,5.0965,10.1601,0.3804,0.0,9.0571,9.0571,9.0571,9.0571,3.0571
+Ollie Watkins,75.7704,0.4218,0.0539,2.0206,3.5696,0.1062,0.0,5.6532,5.6532,5.6532,5.6532,-0.3468
+Sander Berge,82.1893,0.0428,0.0368,4.2055,8.5859,0.1925,0.0,8.2436,8.2436,8.2436,8.2436,2.2436
+Kristoffer Ajer,66.7083,0.0353,0.04,6.3133,8.6108,0.1157,0.0,8.7748,8.7748,8.7748,8.7748,2.7748
+Sasa Lukic,64.1087,0.1076,0.0818,5.1158,8.8396,0.4202,0.0,8.8241,8.8241,8.8241,8.8241,2.8241
+Lewis Cook,58.0725,0.0113,0.0667,6.1148,11.7456,0.1381,0.078,8.6,8.6,8.6,8.6,5.6
+Rico Henry,56.6783,0.0116,0.0717,3.9376,8.3478,0.1542,0.0,6.015,6.015,6.015,6.015,3.015
+Joseph Gomez,34.4239,0.0211,0.0668,4.4718,7.1538,0.2659,0.0,5.9429,5.9429,5.9429,5.9429,2.9429
+Mikel Merino,48.7314,0.2538,0.112,4.9077,9.6664,0.1386,0.0,4.5583,4.5583,4.5583,4.5583,1.5583
+Gabriel Jesus,28.8163,0.4841,0.0736,3.3668,7.8254,0.481,0.0,4.8218,4.8218,4.8218,4.8218,1.8218
+Dominic Solanke,67.1787,0.2824,0.0334,3.0413,5.535,0.0866,0.0,7.4527,7.4527,7.4527,7.4527,1.4527
+Reinildo,75.4526,0.0071,0.0282,6.1965,10.1647,0.3652,0.0441,8.448,8.448,8.448,8.448,2.448
+Nordi Mukiele,83.0957,0.0791,0.0713,8.1114,12.236,0.1967,0.0,10.3141,10.3141,10.3141,10.3141,4.3141
+Alex Iwobi,84.8508,0.0741,0.1698,2.6644,7.2014,0.1178,0.0,11.5063,11.5063,11.5063,11.5063,5.5063
+Emiliano Buendía,45.6277,0.1506,0.0835,3.3038,7.5885,0.2588,0.0,4.4589,4.4589,4.4589,4.4589,1.4589
+Dominic Calvert-Lewin,73.8994,0.4326,0.0421,1.9821,3.592,0.0658,0.0,4.6187,4.6187,4.6187,4.6187,-1.3813
+Olivier Boscagli,59.0087,0.0184,0.0808,7.8905,14.4618,0.3312,0.0,7.742,7.742,7.742,7.742,4.742
+Rúben Dias,82.2657,0.0355,0.0345,6.0398,9.2057,0.128,0.0,9.8621,9.8621,9.8621,9.8621,3.8621
+Hee-Chan Hwang,54.2547,0.1284,0.0578,2.1253,4.5528,0.1735,0.0,4.1966,4.1966,4.1966,4.1966,1.1966
+Rodrigo Bentancur,69.8144,0.0515,0.0556,6.2548,12.6439,0.3665,0.0,10.7436,10.7436,10.7436,10.7436,4.7436
+Daichi Kamada,70.6573,0.084,0.1183,4.6389,9.5517,0.1828,0.0108,9.0194,9.0194,9.0194,9.0194,3.0194
+Borna Sosa,60.6152,0.014,0.1147,4.6674,8.2582,0.0391,0.0,10.4032,10.4032,10.4032,10.4032,4.4032
+Josh Cullen,84.6731,0.0493,0.0874,5.3521,10.0416,0.127,0.0,8.9813,8.9813,8.9813,8.9813,2.9813
+Marcus Edwards,48.3646,0.1306,0.1673,2.047,5.4119,0.051,0.0006,5.8621,5.8621,5.8621,5.8621,2.8621
+Taiwo Awoniyi,21.427,0.5817,0.0999,2.5243,5.6836,0.243,0.0,2.9031,2.9031,2.9031,2.9031,-0.0969
+Mathias Jensen,54.2856,0.0768,0.1859,3.7352,7.8106,0.1511,0.0,7.4801,7.4801,7.4801,7.4801,4.4801
+Declan Rice,85.4853,0.0975,0.1919,5.2627,10.7477,0.0866,0.0,12.7709,12.7709,12.7709,12.7709,6.7709
+Richarlison,54.6488,0.4494,0.056,3.8676,6.1779,0.2491,0.0,4.2884,4.2884,4.2884,4.2884,1.2884
+Jacob Bruun Larsen,40.5425,0.1035,0.0802,2.2251,4.1629,0.007,0.0,5.4878,5.4878,5.4878,5.4878,2.4878
+Antonee Robinson,72.0543,0.0192,0.1097,7.6283,12.6243,0.2511,0.0,12.8392,12.8392,12.8392,12.8392,6.8392
+Viktor Gyökeres,68.0545,0.53,0.1233,1.7557,4.0739,0.1384,0.0,7.79,7.79,7.79,7.79,1.79
+Yoane Wissa,39.4031,0.4432,0.0942,1.3103,3.9643,0.2066,0.0,2.9307,2.9307,2.9307,2.9307,-0.0693
+Leon Bailey,34.3641,0.0848,0.1621,1.8705,5.4582,0.1826,0.0,6.0711,6.0711,6.0711,6.0711,3.0711
+David Brooks,40.8249,0.2889,0.1808,2.9367,6.3385,0.4421,0.0,7.0783,7.0783,7.0783,7.0783,4.0783
+Rodri,71.416,0.0749,0.1565,5.5869,12.132,0.1594,0.0066,11.4756,11.4756,11.4756,11.4756,5.4756
+Ola Aina,87.771,0.0214,0.0578,6.4386,11.2018,0.1812,0.0,10.9291,10.9291,10.9291,10.9291,4.9291
+Tosin Adarabioyo,51.4545,0.0242,0.0375,9.2791,11.3754,0.1905,0.0,7.2733,7.2733,7.2733,7.2733,4.2733
+Vitaly Janelt,58.8412,0.059,0.1183,5.5421,10.6014,0.3418,0.0,8.0211,8.0211,8.0211,8.0211,5.0211
+Samuel Chukwueze,44.702,0.1419,0.2078,2.1638,5.5374,0.003,0.0,7.0758,7.0758,7.0758,7.0758,4.0758
+Alexander Isak,54.7967,0.44,0.0441,2.2524,4.0183,0.0136,0.0,2.6237,2.6237,2.6237,2.6237,-0.3763
+Axel Tuanzebe,83.8557,0.0357,0.0085,6.4851,8.883,0.1523,0.0,8.6331,8.6331,8.6331,8.6331,2.6331
+Issa Diop,59.8571,0.0117,0.0072,6.4771,8.9997,0.244,0.0,6.0656,6.0656,6.0656,6.0656,3.0656
+Axel Disasi,86.8194,0.1254,0.0172,4.6822,7.4234,0.0654,0.0,8.6204,8.6204,8.6204,8.6204,2.6204
+Jean-Philippe Mateta,79.7908,0.4896,0.0596,2.6123,5.0603,0.0934,0.0,6.1259,6.1259,6.1259,6.1259,0.1259
+James Justin,62.0652,0.0441,0.077,6.0186,8.5668,0.1372,0.0,9.7366,9.7366,9.7366,9.7366,3.7366
+Ezri Konsa,88.8325,0.0397,0.0197,5.1368,8.2151,0.0248,0.0228,9.4391,9.4391,9.4391,9.4391,3.4391
+Ethan Pinnock,81.1245,0.0211,0.021,10.0153,13.0793,0.2137,0.0,11.0029,11.0029,11.0029,11.0029,5.0029
+Joe Worrall,43.3755,0.0332,0.0254,9.5104,11.7861,0.0839,0.0072,7.7185,7.7185,7.7185,7.7185,4.7185
+Joe Rodon,88.0996,0.0397,0.0213,7.6086,10.6963,0.0631,0.0015,9.9441,9.9441,9.9441,9.9441,3.9441
+Daniel James,33.1884,0.193,0.1562,2.4656,5.1513,0.0408,0.0,6.4574,6.4574,6.4574,6.4574,3.4574
+Konstantinos Mavropanos,76.8195,0.0899,0.0197,9.6606,13.1147,0.1431,0.0,11.1964,11.1964,11.1964,11.1964,5.1964
+Yves Bissouma,56.8711,0.0514,0.0206,6.2676,10.7123,0.3919,0.0015,6.508,6.508,6.508,6.508,3.508
+Matty Cash,85.9965,0.0419,0.0846,5.6019,8.6916,0.2683,0.0,10.1969,10.1969,10.1969,10.1969,4.1969
+Tyler Adams,77.7528,0.0398,0.0267,6.3601,11.3884,0.3856,0.0,9.4939,9.4939,9.4939,9.4939,3.4939
+Kyle Walker-Peters,57.6847,0.0395,0.0382,5.4612,9.1859,0.1506,0.0,6.3501,6.3501,6.3501,6.3501,3.3501
+Erling Haaland,84.0367,0.7391,0.0748,2.3317,3.507,0.0464,0.0,7.7622,7.7622,7.7622,7.7622,1.7622
+Gabriel Gudmundsson,78.7697,0.0381,0.0781,5.3023,9.0553,0.1881,0.0,9.2921,9.2921,9.2921,9.2921,3.2921
+Reiss Nelson,35.3623,0.1055,0.0782,1.8347,4.6282,0.1015,0.0,7.9878,7.9878,7.9878,7.9878,4.9878
+Tammy Abraham,53.7219,0.4622,0.1129,2.257,3.4025,0.1158,0.0,2.1343,2.1343,2.1343,2.1343,-0.8657
+Kai Havertz,48.8885,0.1738,0.0398,1.8911,3.5802,0.0665,0.0,4.3015,4.3015,4.3015,4.3015,1.3015
+Mason Mount,44.3782,0.2043,0.1028,2.582,6.1404,0.0426,0.0,5.3445,5.3445,5.3445,5.3445,2.3445
+Diogo Dalot,78.1651,0.0894,0.0705,5.5066,10.1093,0.3011,0.0,10.5698,10.5698,10.5698,10.5698,4.5698
+Omar Alderete,87.3022,0.0498,0.0305,9.3049,12.7297,0.2404,0.0032,10.908,10.908,10.908,10.908,4.908
+Kevin Danso,59.0227,0.0334,0.021,10.523,14.3474,0.3133,0.0007,7.5376,7.5376,7.5376,7.5376,4.5376
+Joshua Dasilva,33.3575,0.0614,0.0583,1.4602,3.8804,0.0382,0.0,5.4362,5.4362,5.4362,5.4362,2.4362
+Aaron Wan-Bissaka,86.7635,0.0117,0.0504,6.9512,10.4543,0.1421,0.0,11.6128,11.6128,11.6128,11.6128,5.6128
+Harvey Barnes,54.9657,0.327,0.1551,2.3325,5.2094,0.0484,0.0,6.1454,6.1454,6.1454,6.1454,3.1454
+Nikola Milenkovic,90.0,0.0452,0.0168,7.3226,10.155,0.1701,0.0,9.6987,9.6987,9.6987,9.6987,3.6987
+Igor Julio,73.1054,0.0098,0.0203,4.354,8.8904,0.3295,0.0,9.6899,9.6899,9.6899,9.6899,3.6899
+Jean-Ricner Bellegarde,49.3081,0.0684,0.0887,3.5704,6.2098,0.2374,0.0119,5.7131,5.7131,5.7131,5.7131,2.7131
+Matthijs de Ligt,87.8321,0.1088,0.0449,7.5112,10.7328,0.0564,0.0,10.6622,10.6622,10.6622,10.6622,4.6622
+Ismaïla Sarr,84.5332,0.3358,0.0834,2.6434,5.8199,0.1026,0.0,7.3681,7.3681,7.3681,7.3681,1.3681
+Ryan Sessegnon,64.1123,0.0688,0.082,6.5739,9.9008,0.0353,0.0,9.0202,9.0202,9.0202,9.0202,3.0202
+Ferdi Kadioglu,80.6014,0.0508,0.0823,4.7036,8.1711,0.1332,0.0,9.8008,9.8008,9.8008,9.8008,3.8008
+Noussair Mazraoui,45.6921,0.0146,0.0445,5.5754,8.8567,0.0914,0.0,7.0279,7.0279,7.0279,7.0279,4.0279
+Ryan Yates,29.1609,0.0601,0.0319,5.544,8.4903,0.2789,0.0,4.6023,4.6023,4.6023,4.6023,1.6023
+Ben White,60.2477,0.0762,0.1069,5.9675,9.6356,0.0576,0.0,10.3367,10.3367,10.3367,10.3367,4.3367
+Ethan Ampadu,87.7042,0.056,0.0648,6.4113,11.9863,0.2867,0.0,8.9965,8.9965,8.9965,8.9965,2.9965
+Federico Chiesa,19.2337,0.1404,0.0781,2.1516,3.23,0.2043,0.0,3.8858,3.8858,3.8858,3.8858,0.8858
+Marcos Senesi,85.6027,0.0547,0.1105,10.0739,14.7792,0.3196,0.0,12.0188,12.0188,12.0188,12.0188,6.0188
+Douglas Luiz,47.5641,0.0702,0.1472,3.9758,9.0541,0.1881,0.0001,7.7734,7.7734,7.7734,7.7734,4.7734
+Cristian Romero,81.5152,0.0751,0.0585,8.1894,12.9894,0.4079,0.0362,10.8331,10.8331,10.8331,10.8331,4.8331
+Morgan Gibbs-White,85.0477,0.2302,0.0971,2.5083,5.7088,0.1275,0.0,9.6189,9.6189,9.6189,9.6189,3.6189
+Marcus Tavernier,77.1869,0.2595,0.1394,3.7547,8.4673,0.2205,0.0,10.4859,10.4859,10.4859,10.4859,4.4859
+Jayden Bogle,83.6295,0.0838,0.0748,5.5603,9.7556,0.2476,0.0,8.5493,8.5493,8.5493,8.5493,2.5493
+Joël Piroe,66.4963,0.3835,0.086,2.2183,4.5485,0.0724,0.0015,7.2423,7.2423,7.2423,7.2423,1.2423
+Pau Torres,82.0269,0.0342,0.023,5.2792,9.4586,0.0298,0.0,9.5874,9.5874,9.5874,9.5874,3.5874
+Florentino,64.4552,0.0417,0.0289,7.7288,12.5273,0.2199,0.0,8.0245,8.0245,8.0245,8.0245,2.0245
+Trevoh Chalobah,86.8209,0.0501,0.031,7.8532,11.6842,0.1189,0.0238,10.7884,10.7884,10.7884,10.7884,4.7884
+Justin Kluivert,53.4828,0.2143,0.1129,1.9868,5.661,0.3039,0.0,5.8771,5.8771,5.8771,5.8771,2.8771
+Gabriel,86.3562,0.0879,0.0612,7.4316,9.656,0.1304,0.0,9.7852,9.7852,9.7852,9.7852,3.7852
+Ibrahim Sangaré,72.8384,0.0455,0.0691,5.8889,10.9005,0.2705,0.0,8.8789,8.8789,8.8789,8.8789,2.8789
+Pascal Struijk,86.0099,0.099,0.0281,8.1066,12.1234,0.1251,0.0,10.0097,10.0097,10.0097,10.0097,4.0097
+Ladislav Krejcí,85.6093,0.0647,0.0434,5.5143,8.0472,0.2232,0.0,8.4131,8.4131,8.4131,8.4131,2.4131
+Cody Gakpo,71.7538,0.2982,0.1759,3.125,6.3458,0.1215,0.0,9.8509,9.8509,9.8509,9.8509,3.8509
+Reece James,68.3671,0.0438,0.1363,5.2124,9.7272,0.1909,0.0194,11.1369,11.1369,11.1369,11.1369,5.1369
+Phil Foden,68.9227,0.2373,0.2173,2.9268,6.5894,0.1746,0.0,12.2358,12.2358,12.2358,12.2358,6.2358
+Boubacar Kamara,77.1563,0.0271,0.0496,4.9313,9.1228,0.2124,0.0003,9.1448,9.1448,9.1448,9.1448,3.1448
+Eberechi Eze,60.2754,0.253,0.132,3.0786,6.9162,0.0519,0.0,11.053,11.053,11.053,11.053,5.053
+Sean Longstaff,52.4896,0.0751,0.0945,4.8143,8.1738,0.1177,0.0,7.4215,7.4215,7.4215,7.4215,4.4215
+Ibrahima Konaté,85.3651,0.0446,0.0329,7.8636,11.4578,0.215,0.0,10.0037,10.0037,10.0037,10.0037,4.0037
+Jørgen Strand Larsen,67.8845,0.2333,0.0315,2.1191,3.5862,0.1751,0.0,5.034,5.034,5.034,5.034,-0.966
+Jorge Cuenca,63.7189,0.009,0.0373,9.1543,12.6348,0.3462,0.0,10.6979,10.6979,10.6979,10.6979,4.6979
+Valentín Castellanos,72.4277,0.3205,0.0805,2.6593,4.5927,0.2502,0.0085,6.5152,6.5152,6.5152,6.5152,0.5152
+Randal Kolo Muani,54.2872,0.2001,0.0793,2.4276,4.9604,0.112,0.0,2.8491,2.8491,2.8491,2.8491,-0.1509
+Nicolás Dominguez,48.3402,0.0661,0.0391,4.8677,8.057,0.2303,0.0,6.1064,6.1064,6.1064,6.1064,3.1064
+Hjalmar Ekdal,79.9099,0.0176,0.0173,9.2071,12.1149,0.066,0.0,10.2096,10.2096,10.2096,10.2096,4.2096
+Alexis Mac Allister,73.0199,0.1151,0.09,4.5682,8.7472,0.2046,0.0026,10.1764,10.1764,10.1764,10.1764,4.1764
+Omar Marmoush,39.7284,0.3141,0.1159,2.545,4.5655,0.243,0.0,4.9523,4.9523,4.9523,4.9523,1.9523
+Pedro Neto,74.9889,0.1611,0.2136,2.1142,5.2702,0.2074,0.0,11.5034,11.5034,11.5034,11.5034,5.5034
+Marc Guéhi,89.9962,0.1027,0.067,7.5721,11.9556,0.1941,0.0,10.6024,10.6024,10.6024,10.6024,4.6024
+Dominik Szoboszlai,87.0945,0.1507,0.1654,4.0111,9.1403,0.3035,0.0169,11.819,11.819,11.819,11.819,5.819
+Jadon Sancho,42.2505,0.0586,0.1699,1.7187,4.2579,0.0106,0.0,7.0595,7.0595,7.0595,7.0595,4.0595
+Callum Hudson-Odoi,61.8546,0.1233,0.1112,2.0552,5.4534,0.0204,0.0,10.877,10.877,10.877,10.877,4.877
+Lisandro Martínez,67.6503,0.0193,0.049,6.7024,11.4997,0.1211,0.0,10.7857,10.7857,10.7857,10.7857,4.7857
+Santiago Bueno,83.5731,0.0591,0.0346,6.5662,8.9756,0.1334,0.0,9.189,9.189,9.189,9.189,3.189
+Angel Gomes,55.6449,0.1327,0.108,1.9235,4.4371,0.2352,0.0,4.7642,4.7642,4.7642,4.7642,1.7642
+Bruno Guimarães,87.5603,0.1618,0.1555,4.2669,9.2128,0.2123,0.0,10.0484,10.0484,10.0484,10.0484,4.0484
+Daniel Muñoz,85.1446,0.1091,0.145,7.2831,11.5878,0.2468,0.0,11.3449,11.3449,11.3449,11.3449,5.3449
+Edward Nketiah,34.7596,0.3138,0.0749,3.6569,5.753,0.3237,0.0,4.5356,4.5356,4.5356,4.5356,1.5356
+Joseph Willock,34.769,0.0903,0.0641,3.1379,7.0043,0.222,0.0,4.8581,4.8581,4.8581,4.8581,1.8581
+Lukas Nmecha,33.5304,0.4637,0.0749,1.97,4.0155,0.0442,0.0,2.9531,2.9531,2.9531,2.9531,-0.0469
+Jordan Beyer,82.7768,0.0356,0.0137,7.344,11.4945,0.3353,0.0,11.5591,11.5591,11.5591,11.5591,5.5591
+Jaka Bijol,74.6076,0.0466,0.0349,9.2427,12.4264,0.2104,0.0,10.3272,10.3272,10.3272,10.3272,4.3272
+Kaoru Mitoma,71.4493,0.2194,0.1541,2.355,5.5024,0.1542,0.0,9.1618,9.1618,9.1618,9.1618,3.1618
+Matheus Cunha,74.7177,0.28,0.1265,3.5551,7.7408,0.07,0.0,10.7174,10.7174,10.7174,10.7174,4.7174
+Tyrell Malacia,46.5198,0.0187,0.0903,3.3557,6.2804,0.229,0.0,6.2871,6.2871,6.2871,6.2871,3.2871
+Max Kilman,76.0503,0.0361,0.021,7.6773,10.66,0.2022,0.0,9.7598,9.7598,9.7598,9.7598,3.7598
+Matthew O'Riley,48.7145,0.1697,0.2013,3.5878,7.2707,0.1613,0.0,6.4833,6.4833,6.4833,6.4833,3.4833
+Sandro Tonali,70.8519,0.0924,0.098,4.0449,9.4939,0.156,0.0,10.9446,10.9446,10.9446,10.9446,4.9446
+Tijjani Reijnders,61.1749,0.2081,0.1208,2.8274,6.0423,0.1327,0.004,9.5231,9.5231,9.5231,9.5231,3.5231
+Marc Cucurella,77.8184,0.0744,0.1047,6.1965,10.2356,0.2547,0.0293,10.4429,10.4429,10.4429,10.4429,4.4429
+Zian Flemming,56.1101,0.3654,0.0403,3.2368,4.9644,0.1881,0.0,2.914,2.914,2.914,2.914,-0.086
+Vitaliy Mykolenko,89.4196,0.0153,0.0781,6.9707,10.3543,0.162,0.0,10.9489,10.9489,10.9489,10.9489,4.9489
+Calvin Bassey,83.3652,0.061,0.0163,6.4172,11.0544,0.2027,0.0,9.6617,9.6617,9.6617,9.6617,3.6617
+Lyle Foster,56.8255,0.2068,0.0332,2.5299,4.7678,0.2174,0.0039,2.2263,2.2263,2.2263,2.2263,-0.7737
+Lutsharel Geertruida,58.0435,0.0561,0.0629,5.5893,9.447,0.0873,0.0,6.0484,6.0484,6.0484,6.0484,3.0484
+Anton Stach,82.8997,0.089,0.1665,5.5948,10.4824,0.145,0.0,11.8092,11.8092,11.8092,11.8092,5.8092
+Morgan Rogers,88.3658,0.1934,0.1311,2.7539,6.2044,0.2039,0.0,8.6924,8.6924,8.6924,8.6924,2.6924
+Kiernan Dewsbury-Hall,83.7372,0.1551,0.1999,3.2397,7.8093,0.1917,0.0,10.1337,10.1337,10.1337,10.1337,4.1337
+Wilson Isidor,44.9924,0.3056,0.024,2.3576,3.8195,0.1799,0.0,3.4082,3.4082,3.4082,3.4082,0.4082
+Mikkel Damsgaard,62.8194,0.0891,0.2078,4.3437,9.753,0.0407,0.0,11.7283,11.7283,11.7283,11.7283,5.7283
+Emile Smith Rowe,50.3994,0.2185,0.0613,2.9267,5.8764,0.07,0.0,5.5986,5.5986,5.5986,5.5986,2.5986
+Mohammed Kudus,81.3113,0.1378,0.1192,2.7641,7.9315,0.138,0.0012,9.5315,9.5315,9.5315,9.5315,3.5315
+Djed Spence,74.9913,0.0345,0.0545,5.1277,9.8425,0.1589,0.0,10.0475,10.0475,10.0475,10.0475,4.0475
+Anthony Gordon,70.002,0.378,0.1686,2.2215,5.1708,0.1419,0.0325,9.7423,9.7423,9.7423,9.7423,3.7423
+Noah Okafor,50.9246,0.2393,0.0921,2.7505,5.3229,0.1532,0.0,5.7142,5.7142,5.7142,5.7142,2.7142
+Wesley Fofana,69.4005,0.0412,0.0323,8.4518,12.7418,0.4182,0.0,10.8891,10.8891,10.8891,10.8891,4.8891
+Sepp van den Berg,87.9126,0.0936,0.0261,7.9593,11.7922,0.0859,0.0,10.6229,10.6229,10.6229,10.6229,4.6229
+Sebastiaan Bornauw,36.5758,0.0249,0.006,8.4324,10.9426,0.2545,0.0,5.9284,5.9284,5.9284,5.9284,2.9284
+Bryan Mbeumo,85.1668,0.3054,0.1142,2.7242,5.139,0.1031,0.0,9.122,9.122,9.122,9.122,3.122
+Antoine Semenyo,88.9138,0.2902,0.0862,3.0602,7.3072,0.2266,0.0,8.4555,8.4555,8.4555,8.4555,2.4555
+Curtis Jones,50.1405,0.1534,0.1139,3.5072,8.9359,0.098,0.0057,6.5557,6.5557,6.5557,6.5557,3.5557
+Rayan Aït-Nouri,63.3312,0.0623,0.1452,6.6285,11.4224,0.2607,0.0,11.4304,11.4304,11.4304,11.4304,5.4304
+Dejan Kulusevski,74.9837,0.1501,0.1598,2.9581,7.1651,0.1375,0.0,10.2789,10.2789,10.2789,10.2789,4.2789
+Ao Tanaka,41.7624,0.0928,0.0638,3.5551,7.8022,0.1368,0.0,5.5875,5.5875,5.5875,5.5875,2.5875
+Dwight McNeil,54.2643,0.0626,0.1116,2.8592,6.8728,0.0639,0.0,6.8063,6.8063,6.8063,6.8063,3.8063
+Brian Brobbey,56.3609,0.369,0.0675,1.433,3.6041,0.2691,0.0,1.3468,1.3468,1.3468,1.3468,-1.6532
+Crysencio Summerville,72.8909,0.2052,0.1247,3.6236,7.5776,0.1881,0.0,9.8372,9.8372,9.8372,9.8372,3.8372
+Pedro Porro,80.1312,0.0357,0.1355,6.0851,10.5601,0.1834,0.0001,13.0023,13.0023,13.0023,13.0023,7.0023
+Jérémy Doku,55.4217,0.1166,0.2592,2.4255,5.8968,0.0267,0.0,9.6308,9.6308,9.6308,9.6308,6.6308
+Jurriën Timber,81.7478,0.1352,0.0566,4.9202,8.453,0.163,0.0,8.4838,8.4838,8.4838,8.4838,2.4838
+James Garner,87.9932,0.0579,0.12,6.7268,11.3205,0.238,0.0,12.3629,12.3629,12.3629,12.3629,6.3629
+Maxence Lacroix,88.8248,0.0759,0.0295,10.052,13.225,0.1215,0.0302,10.8061,10.8061,10.8061,10.8061,4.8061
+Chris Richards,88.4833,0.0524,0.0389,9.3739,11.5966,0.1255,0.0,10.9864,10.9864,10.9864,10.9864,4.9864
+Joshua Zirkzee,30.2633,0.3208,0.0407,2.6714,5.0198,0.0544,0.0,3.8421,3.8421,3.8421,3.8421,0.8421
+Cheick Oumar Doucouré,40.6868,0.0677,0.0246,7.2194,12.6153,0.1742,0.0,8.874,8.874,8.874,8.874,5.874
+Brenden Aaronson,67.7086,0.1865,0.1258,2.9428,7.1965,0.0547,0.0,7.5291,7.5291,7.5291,7.5291,1.5291
+Jean-Clair Todibo,82.7585,0.0152,0.0152,7.6511,12.3198,0.1855,0.0392,10.5206,10.5206,10.5206,10.5206,4.5206
+Benoît Badiashile,59.8826,0.0036,0.0179,7.7847,11.3785,0.1728,0.0,6.8641,6.8641,6.8641,6.8641,3.8641
+William Saliba,83.5068,0.044,0.0369,6.0477,10.4926,0.0541,0.0066,9.8505,9.8505,9.8505,9.8505,3.8505
+Matheus Nunes,81.4042,0.0339,0.0811,5.2496,9.9578,0.1643,0.0,10.4925,10.4925,10.4925,10.4925,4.4925
+Sven Botman,65.1075,0.1052,0.0322,8.018,12.3429,0.1102,0.0,11.3157,11.3157,11.3157,11.3157,5.3157
+Ryan Gravenberch,86.7602,0.0593,0.0809,5.2197,9.8207,0.1517,0.0063,10.193,10.193,10.193,10.193,4.193
+Georginio Rutter,63.9676,0.1576,0.119,3.6218,6.3912,0.1092,0.0,6.5947,6.5947,6.5947,6.5947,0.5947
+James Hill,64.1043,0.0461,0.0525,10.1973,13.1687,0.109,0.0,10.9715,10.9715,10.9715,10.9715,4.9715
+Nathan Collins,84.472,0.059,0.0372,8.0217,12.1997,0.1643,0.0012,10.5104,10.5104,10.5104,10.5104,4.5104
+Bukayo Saka,73.4966,0.3093,0.2918,3.4473,7.7153,0.0813,0.0,12.9207,12.9207,12.9207,12.9207,6.9207
+Harvey Elliott,22.5166,0.2129,0.1671,2.8267,6.2156,0.2193,0.0,8.4308,8.4308,8.4308,8.4308,5.4308
+Fábio Carvalho,28.8812,0.1797,0.0415,1.6262,3.4287,0.0982,0.0,5.1529,5.1529,5.1529,5.1529,2.1529
+Mike Trésor,36.8008,0.0642,0.1648,1.184,3.616,0.0017,0.0017,6.4262,6.4262,6.4262,6.4262,3.4262
+Iliman Ndiaye,84.6356,0.1811,0.1314,3.1757,8.5839,0.0686,0.0076,9.3019,9.3019,9.3019,9.3019,3.3019
+Jeremie Frimpong,52.7721,0.0894,0.1165,2.6995,6.4162,0.1354,0.0,6.8415,6.8415,6.8415,6.8415,3.8415
+Ian Maatsen,50.6532,0.0752,0.1464,6.7681,12.0113,0.1654,0.0007,8.7191,8.7191,8.7191,8.7191,5.7191
+Conor Gallagher,45.5652,0.1023,0.0606,3.5725,7.6757,0.1487,0.0,4.851,4.851,4.851,4.851,1.851
+Mats Wieffer,70.4765,0.085,0.112,8.5908,13.8246,0.3667,0.0,11.2894,11.2894,11.2894,11.2894,5.2894
+Daniel Ballard,75.1937,0.1039,0.023,9.6698,12.9468,0.1763,0.0,10.4749,10.4749,10.4749,10.4749,4.4749
+Jan Paul van Hecke,88.743,0.0665,0.0399,7.5791,10.9377,0.241,0.0,10.534,10.534,10.534,10.534,4.534
+Mykhaylo Mudryk,49.9593,0.1785,0.1263,1.5776,3.9101,0.1768,0.0,6.1416,6.1416,6.1416,6.1416,3.1416
+Bafodé Diakité,73.2366,0.0267,0.018,6.9524,10.7379,0.1204,0.0,9.1616,9.1616,9.1616,9.1616,3.1616
+Aaron Hickey,39.0821,0.0472,0.0138,4.007,8.0058,0.2139,0.0,4.8348,4.8348,4.8348,4.8348,1.8348
+Keane Lewis-Potter,50.8241,0.1252,0.0911,3.1746,6.7151,0.0641,0.0,6.6342,6.6342,6.6342,6.6342,3.6342
+Toti Gomes,75.7854,0.0232,0.0178,7.4731,11.1206,0.1909,0.0585,11.2192,11.2192,11.2192,11.2192,5.2192
+João Pedro,74.5961,0.4491,0.0975,2.7339,5.3033,0.1342,0.0017,7.8275,7.8275,7.8275,7.8275,1.8275
+Gabriel Martinelli,38.517,0.3204,0.1163,2.3713,6.0777,0.1571,0.0,5.797,5.797,5.797,5.797,2.797
+Jacob Ramsey,51.8772,0.0787,0.072,2.809,7.1378,0.2834,0.0,5.7475,5.7475,5.7475,5.7475,2.7475
+Dan Ndoye,53.7756,0.1437,0.1097,3.052,6.5955,0.1126,0.0,4.8186,4.8186,4.8186,4.8186,1.8186
+Jarrad Branthwaite,65.6957,0.0545,0.0149,7.4916,10.0959,0.1094,0.0,10.6128,10.6128,10.6128,10.6128,4.6128
+Martín Zubimendi,83.7754,0.0914,0.0671,5.4809,9.3376,0.1594,0.0,8.825,8.825,8.825,8.825,2.825
+Manuel Ugarte,40.8001,0.0458,0.0183,7.7418,13.5736,0.2448,0.0,5.6427,5.6427,5.6427,5.6427,2.6427
+Yéremi Pino,64.1448,0.168,0.1828,3.3484,6.6032,0.2267,0.0,7.8596,7.8596,7.8596,7.8596,1.8596
+David Møller Wolfe,51.4133,0.0231,0.0918,3.5772,6.1115,0.1064,0.0075,5.8076,5.8076,5.8076,5.8076,2.8076
+Enzo Le Fée,77.9089,0.0922,0.1025,4.3836,8.4172,0.1585,0.0,9.136,9.136,9.136,9.136,3.136
+Anthony Elanga,47.8001,0.1197,0.1091,1.7247,4.1398,0.0103,0.0,5.9113,5.9113,5.9113,5.9113,2.9113
+Destiny Udogie,62.3729,0.0225,0.0597,4.1026,8.8399,0.2853,0.0,8.9714,8.9714,8.9714,8.9714,2.9714
+Morato,59.2415,0.0627,0.0072,7.761,11.9325,0.3581,0.0,6.7099,6.7099,6.7099,6.7099,3.7099
+Zeki Amdouni,36.9928,0.2697,0.1307,2.0035,4.7107,0.0719,0.0,5.4058,5.4058,5.4058,5.4058,2.4058
+Trai Hume,83.8605,0.0516,0.0786,6.0814,9.6169,0.2459,0.0035,9.4073,9.4073,9.4073,9.4073,3.4073
+Amad,76.2846,0.1979,0.1464,3.8464,8.2369,0.127,0.0,11.9631,11.9631,11.9631,11.9631,5.9631
+Josko Gvardiol,82.4289,0.132,0.0505,5.8602,9.3448,0.1236,0.0,9.4467,9.4467,9.4467,9.4467,3.4467
+Tolu Arokodare,47.0023,0.3963,0.0367,3.0882,4.6942,0.0699,0.0,2.9966,2.9966,2.9966,2.9966,-0.0034
+Benjamin Sesko,54.0307,0.3938,0.0282,1.8954,3.5596,0.1098,0.0,3.9752,3.9752,3.9752,3.9752,0.9752
+Brennan Johnson,48.2584,0.1793,0.0594,2.7178,4.8402,0.2576,0.0,5.1978,5.1978,5.1978,5.1978,2.1978
+Armando Broja,39.6652,0.1686,0.0185,2.2725,4.879,0.0608,0.0,2.2664,2.2664,2.2664,2.2664,-0.7336
+Neco Williams,85.5942,0.0473,0.0941,7.1224,11.4786,0.1919,0.0232,11.8488,11.8488,11.8488,11.8488,5.8488
+Beto,40.4443,0.5053,0.0204,3.5613,5.5271,0.1434,0.0,2.2369,2.2369,2.2369,2.2369,-0.7631
+Dilane Bakwa,40.8753,0.0669,0.1378,1.3206,4.0673,0.1119,0.0022,6.4094,6.4094,6.4094,6.4094,3.4094
+Amine Adli,38.1867,0.237,0.143,3.9854,7.8686,0.2161,0.0064,4.9567,4.9567,4.9567,4.9567,1.9567
+Ilia Gruev,63.2283,0.0354,0.0668,3.6066,6.7117,0.1882,0.0,8.1832,8.1832,8.1832,8.1832,2.1832
+Rhys Williams,59.0793,0.0311,0.0042,4.4377,7.1301,0.1056,0.0,5.3508,5.3508,5.3508,5.3508,2.3508
+Igor Jesus,63.9319,0.2378,0.06,2.9492,5.014,0.0026,0.0,6.4646,6.4646,6.4646,6.4646,0.4646
+Kevin Schade,76.7491,0.3576,0.0728,3.117,6.2569,0.1911,0.0277,7.4974,7.4974,7.4974,7.4974,1.4974
+Noni Madueke,47.4266,0.1796,0.187,3.1812,5.7814,0.04,0.0,8.2122,8.2122,8.2122,8.2122,5.2122
+Evann Guessand,50.761,0.1614,0.0986,3.1724,6.6787,0.0137,0.0,3.2438,3.2438,3.2438,3.2438,0.2438
+Elliot Anderson,87.4783,0.0747,0.1151,5.9657,13.6638,0.2265,0.0,12.1632,12.1632,12.1632,12.1632,6.1632
+Cole Palmer,73.2632,0.419,0.1574,3.1644,6.8453,0.1888,0.0,11.2779,11.2779,11.2779,11.2779,5.2779
+Levi Colwill,88.4326,0.0535,0.0325,5.7177,9.4928,0.1771,0.0,10.0217,10.0217,10.0217,10.0217,4.0217
+Micky van de Ven,85.1519,0.0778,0.0244,5.8832,10.0799,0.2736,0.0252,9.7194,9.7194,9.7194,9.7194,3.7194
+Evanilson,75.6931,0.3737,0.0697,1.8184,4.4082,0.054,0.0119,6.3751,6.3751,6.3751,6.3751,0.3751
+Jake O'Brien,84.1167,0.0411,0.0245,6.3849,9.7345,0.1108,0.0264,9.8303,9.8303,9.8303,9.8303,3.8303
+Rayan Cherki,54.3913,0.1635,0.4037,2.6652,6.9577,0.0351,0.0,9.4148,9.4148,9.4148,9.4148,6.4148
+Riccardo Calafiori,64.265,0.1363,0.0427,5.4635,8.7902,0.2974,0.0,9.6881,9.6881,9.6881,9.6881,3.6881
+Nick Woltemade,62.3292,0.3229,0.0801,2.7048,5.1076,0.0607,0.0,6.0716,6.0716,6.0716,6.0716,0.0716
+Pape Sarr,59.1841,0.0941,0.0608,5.6164,10.1001,0.1794,0.0,6.1899,6.1899,6.1899,6.1899,3.1899
+Wilfried Gnonto,27.5683,0.1078,0.0812,4.0544,7.2597,0.5541,0.0,4.5717,4.5717,4.5717,4.5717,1.5717
+James McAtee,27.5175,0.3906,0.0589,1.9007,4.4039,0.05,0.0,4.8698,4.8698,4.8698,4.8698,1.8698
+Valentino Livramento,77.4971,0.0117,0.0683,4.6642,9.7494,0.0636,0.0,10.7559,10.7559,10.7559,10.7559,4.7559
+Nathan Patterson,36.5152,0.0191,0.0666,3.9913,6.9515,0.2266,0.0,8.4676,8.4676,8.4676,8.4676,5.4676
+Conor Bradley,59.1709,0.0417,0.1062,5.5976,9.7784,0.3706,0.0,6.4553,6.4553,6.4553,6.4553,3.4553
+Jamie Gittens,33.9062,0.1518,0.168,2.677,5.0836,0.0396,0.0,6.7743,6.7743,6.7743,6.7743,3.7743
+Hannibal Mejbri,44.2434,0.0529,0.0929,3.044,6.8682,0.4251,0.0055,4.1983,4.1983,4.1983,4.1983,1.1983
+Oscar Bobb,44.2702,0.0958,0.1222,2.2547,4.8983,0.0798,0.0,5.4626,5.4626,5.4626,5.4626,2.4626
+Liam Delap,40.4728,0.3733,0.03,1.9564,3.9814,0.2554,0.0,3.1751,3.1751,3.1751,3.1751,0.1751
+Hugo Bueno,68.4422,0.0253,0.1305,5.3578,9.4965,0.0641,0.0,11.8044,11.8044,11.8044,11.8044,5.8044
+Dennis Cirkin,47.6861,0.0236,0.03,7.0159,9.5407,0.3101,0.0,5.4027,5.4027,5.4027,5.4027,2.4027
+Tyrick Mitchell,88.2977,0.0373,0.0663,6.0499,10.7413,0.1388,0.0002,10.611,10.611,10.611,10.611,4.611
+Romaine Mundle,33.2089,0.1008,0.071,1.9692,4.8319,0.1818,0.0,4.7529,4.7529,4.7529,4.7529,1.7529
+Rodrigo Muniz,40.0262,0.3739,0.0149,4.0327,5.5515,0.1365,0.0,2.7251,2.7251,2.7251,2.7251,-0.2749
+Charly Alcaraz,42.8533,0.1419,0.0488,2.9617,6.9197,0.2908,0.0002,6.2849,6.2849,6.2849,6.2849,3.2849
+Maxim De Cuyper,52.6835,0.1024,0.1978,4.4165,8.7511,0.1667,0.0,8.2956,8.2956,8.2956,8.2956,5.2956
+Malick Thiaw,83.1742,0.1063,0.0265,7.6616,11.3401,0.1308,0.0041,9.6095,9.6095,9.6095,9.6095,3.6095
+Piero Hincapié,73.8871,0.0494,0.1001,7.0821,10.4495,0.1436,0.0005,9.4022,9.4022,9.4022,9.4022,3.4022
+Moisés Caicedo,84.5964,0.0438,0.0827,6.294,12.2565,0.3618,0.0279,9.8801,9.8801,9.8801,9.8801,3.8801
+Enzo Fernández,85.5435,0.2904,0.1775,3.297,7.2089,0.2562,0.0,9.6035,9.6035,9.6035,9.6035,3.6035
+Florian Wirtz,74.8042,0.2429,0.2216,2.5447,6.569,0.0429,0.0,10.4041,10.4041,10.4041,10.4041,4.4041
+Luca Netz,55.6359,0.0114,0.0975,5.3227,8.2574,0.1027,0.0,6.3843,6.3843,6.3843,6.3843,3.3843
+Yehor Yarmoliuk,66.0112,0.0527,0.0524,4.6962,10.9059,0.2907,0.0,9.5066,9.5066,9.5066,9.5066,3.5066
+Yasin Ayari,69.9335,0.1259,0.0633,4.6479,9.952,0.0975,0.0,9.9672,9.9672,9.9672,9.9672,3.9672
+Jaidon Anthony,72.6748,0.1919,0.119,3.4996,8.085,0.1314,0.0,10.0903,10.0903,10.0903,10.0903,4.0903
+Xavi Simons,67.7422,0.1262,0.1733,2.9025,6.9162,0.1599,0.0051,9.8097,9.8097,9.8097,9.8097,3.8097
+André,76.1536,0.0164,0.0294,5.5794,12.4388,0.3411,0.0008,9.6029,9.6029,9.6029,9.6029,3.6029
+Savinho,36.8613,0.2163,0.2094,2.3971,6.3809,0.1433,0.0,6.2472,6.2472,6.2472,6.2472,3.2472
+João Gomes,79.758,0.0537,0.0687,6.048,12.2979,0.3581,0.0,9.5715,9.5715,9.5715,9.5715,3.5715
+Adrien Truffert,88.0282,0.0184,0.0719,7.2286,11.8795,0.1773,0.0,10.4511,10.4511,10.4511,10.4511,4.4511
+Amadou Onana,70.0839,0.0818,0.0401,6.703,10.5225,0.1547,0.0,9.3309,9.3309,9.3309,9.3309,3.3309
+Chadi Riad,56.3634,0.014,0.0115,4.6692,7.8654,0.3977,0.0,4.9832,4.9832,4.9832,4.9832,1.9832
+Lamare Bogarde,36.7301,0.0009,0.0154,3.6559,6.2708,0.3471,0.0,3.9567,3.9567,3.9567,3.9567,0.9567
+Roméo Lavia,53.5626,0.0198,0.033,4.7947,9.3437,0.3879,0.0,7.4837,7.4837,7.4837,7.4837,4.4837
+Rodrigo Gomes,39.0568,0.1139,0.0311,2.7758,4.6043,0.0221,0.0009,5.4555,5.4555,5.4555,5.4555,2.4555
+Milos Kerkez,74.6702,0.0564,0.0421,5.2971,9.0952,0.1622,0.0037,10.4707,10.4707,10.4707,10.4707,4.4707
+Hugo Ekitiké,66.4009,0.4976,0.1483,2.7203,4.9566,0.0313,0.0,7.5181,7.5181,7.5181,7.5181,1.5181
+Malo Gusto,61.7349,0.0687,0.0942,4.5824,9.2656,0.1836,0.0039,9.9092,9.9092,9.9092,9.9092,3.9092
+Lewis Hall,74.0676,0.0363,0.1285,6.3973,11.6696,0.1857,0.0,12.6354,12.6354,12.6354,12.6354,6.6354
+Lesley Ugochukwu,65.7971,0.0746,0.0162,4.0754,7.6819,0.1931,0.0014,7.7189,7.7189,7.7189,7.7189,1.7189
+Yerson Mosquera,79.1589,0.0829,0.021,8.3565,12.7682,0.4628,0.0,9.7487,9.7487,9.7487,9.7487,3.7487
+Tim Iroegbunam,45.9773,0.0283,0.0395,5.6372,10.5542,0.5435,0.0,4.1552,4.1552,4.1552,4.1552,1.1552
+Radu Dragusin,65.9592,0.038,0.0066,8.589,10.9029,0.0224,0.0,9.2994,9.2994,9.2994,9.2994,3.2994
+Alejandro Garnacho,56.8659,0.2823,0.2016,2.3743,5.5952,0.1103,0.0,5.9239,5.9239,5.9239,5.9239,2.9239
+Freddie Potts,60.5335,0.0201,0.0578,4.5424,7.2826,0.0968,0.0,8.4227,8.4227,8.4227,8.4227,2.4227
+Merlin Röhl,32.9049,0.0749,0.0465,2.738,5.5585,0.0412,0.0049,2.5037,2.5037,2.5037,2.5037,-0.4963
+Jackson Tchatchoua,64.2148,0.0204,0.0814,4.1717,6.9474,0.1357,0.0,9.5712,9.5712,9.5712,9.5712,3.5712
+Lorenzo Lucca,33.1764,0.2448,0.022,1.5783,3.3428,0.2117,0.0,1.0382,1.0382,1.0382,1.0382,-1.9618
+Omari Hutchinson,57.2744,0.1063,0.1601,2.3051,6.2931,0.0417,0.0,7.6288,7.6288,7.6288,7.6288,4.6288
+Pablo,64.4283,0.2275,0.0431,3.851,6.6621,0.1542,0.0,5.3899,5.3899,5.3899,5.3899,-0.6101
+Alex Scott,69.975,0.106,0.0705,6.2624,12.1883,0.1737,0.0,11.4208,11.4208,11.4208,11.4208,5.4208
+Bashir Humphreys,81.1397,0.0233,0.0369,6.6504,10.5548,0.2584,0.0,9.299,9.299,9.299,9.299,3.299
+Abdoullah Ba,49.0535,0.0344,0.018,1.7816,3.553,0.156,0.0,3.9978,3.9978,3.9978,3.9978,0.9978
+Dário Essugo,67.6699,0.0205,0.0237,5.8284,10.6501,0.414,0.0,7.7005,7.7005,7.7005,7.7005,1.7005
+Dango Ouattara,67.9332,0.2433,0.1385,4.9938,8.7618,0.1329,0.0,9.7569,9.7569,9.7569,9.7569,3.7569
+Maxime Estève,86.1932,0.0237,0.0199,8.446,12.0462,0.0371,0.0,10.2633,10.2633,10.2633,10.2633,4.2633
+Jack Hinshelwood,60.5217,0.1213,0.0791,2.7297,5.4951,0.0543,0.0,7.2746,7.2746,7.2746,7.2746,1.2746
+William Osula,19.2368,0.1565,0.0087,1.3492,3.9219,0.0869,0.0,3.197,3.197,3.197,3.197,0.197
+Antoni Milambo,59.7901,0.061,0.056,2.0112,4.3345,0.0703,0.0,4.0933,4.0933,4.0933,4.0933,1.0933
+Nico González,67.2308,0.0669,0.0655,5.6697,10.3898,0.3059,0.012,8.2844,8.2844,8.2844,8.2844,2.2844
+Loum Tchaouna,35.8091,0.0873,0.0429,2.3049,3.8955,0.0852,0.0,3.8896,3.8896,3.8896,3.8896,0.8896
+Habib Diarra,78.6907,0.1435,0.0668,2.43,5.0999,0.2505,0.0,7.3148,7.3148,7.3148,7.3148,1.3148
+Nilson Angulo,74.7504,0.1447,0.1535,4.4396,8.2221,0.0664,0.0277,9.508,9.508,9.508,9.508,3.508
+Mathys Tel,39.7785,0.1452,0.1017,2.2308,5.6376,0.0489,0.0,6.9962,6.9962,6.9962,6.9962,3.9962
+Rico Lewis,35.9394,0.035,0.184,4.0896,6.5026,0.2169,0.0,5.0106,5.0106,5.0106,5.0106,2.0106
+Lucas Pires,74.6837,0.0295,0.0963,5.6565,10.7784,0.0756,0.0944,10.6803,10.6803,10.6803,10.6803,4.6803
+Kobbie Mainoo,52.6321,0.0221,0.0694,4.3792,9.0528,0.0931,0.0,6.6021,6.6021,6.6021,6.6021,3.6021
+Tyler Dibling,28.1028,0.0668,0.0286,3.3806,6.5985,0.3403,0.0,4.9808,4.9808,4.9808,4.9808,1.9808
+Adam Wharton,78.6639,0.0443,0.222,5.1207,10.6841,0.2299,0.0,10.5291,10.5291,10.5291,10.5291,4.5291
+Lewis Miley,54.6858,0.115,0.1326,5.2793,9.7618,0.0056,0.0,8.6122,8.6122,8.6122,8.6122,5.6122
+Cristhian Mosquera,53.2567,0.0042,0.0451,6.8703,10.331,0.2289,0.0,5.8415,5.8415,5.8415,5.8415,2.8415
+Nico O'Reilly,73.911,0.2047,0.0445,2.454,4.5921,0.0081,0.0,7.8341,7.8341,7.8341,7.8341,1.8341
+Igor Thiago,84.1711,0.4805,0.0671,2.9572,5.361,0.1937,0.0,6.1205,6.1205,6.1205,6.1205,0.1205
+Stefan Bajcetic,59.3475,0.0519,0.0448,4.5461,9.4227,0.3219,0.0,6.1406,6.1406,6.1406,6.1406,3.1406
+Oliver Scarles,53.3652,0.0191,0.0324,7.4714,11.4437,0.1237,0.0,7.1103,7.1103,7.1103,7.1103,4.1103
+Kevin,34.1777,0.0634,0.0646,2.1876,4.5723,0.0503,0.0,6.6387,6.6387,6.6387,6.6387,3.6387
+Archie Gray,65.1382,0.055,0.0493,3.8137,6.8077,0.2325,0.0,8.4235,8.4235,8.4235,8.4235,2.4235
+Ben Gannon Doak,64.7464,0.1483,0.1535,1.5251,3.7866,0.2385,0.0,8.051,8.051,8.051,8.051,2.051
+Chris Rigg,46.8007,0.0961,0.0755,2.7371,5.5118,0.0775,0.0,5.062,5.062,5.062,5.062,2.062
+Facundo Buonanotte,49.0491,0.1925,0.1038,4.0942,8.1996,0.4277,0.0,7.7681,7.7681,7.7681,7.7681,4.7681
+Justin Devenny,31.6051,0.2037,0.0279,2.75,5.2427,0.0414,0.0,4.0726,4.0726,4.0726,4.0726,1.0726
+Wilson Odobert,42.7042,0.1212,0.0855,1.8053,5.4487,0.0136,0.0,6.5921,6.5921,6.5921,6.5921,3.5921
+Matai Akinmboni,47.6087,0.0,0.0139,5.0187,6.9676,0.4176,0.0,4.2692,4.2692,4.2692,4.2692,1.2692
+Carlos Baleba,55.043,0.0557,0.0241,5.4221,10.838,0.3316,0.007,5.4047,5.4047,5.4047,5.4047,2.4047
+Diego Gómez,64.5466,0.2046,0.1314,6.0073,10.6088,0.3024,0.0,8.7393,8.7393,8.7393,8.7393,2.7393
+Sverre Halseth Nypan,36.087,0.1136,0.1175,2.903,5.9343,0.1227,0.0,5.0612,5.0612,5.0612,5.0612,2.0612
+Mateus Fernandes,80.7045,0.0542,0.0914,4.7553,9.6293,0.2344,0.0,9.646,9.646,9.646,9.646,3.646
+Leny Yoro,57.3727,0.0534,0.02,6.8264,10.3785,0.1369,0.0,5.9604,5.9604,5.9604,5.9604,2.9604
+Noah Sadiki,87.8127,0.0309,0.0578,4.418,8.1771,0.2588,0.0,8.4581,8.4581,8.4581,8.4581,2.4581
+Abdukodir Khusanov,61.6895,0.0384,0.0133,7.2718,11.525,0.2245,0.0136,9.7882,9.7882,9.7882,9.7882,3.7882
+Chemsdine Talbi,56.0204,0.188,0.0912,2.0419,5.1501,0.0167,0.0,6.3764,6.3764,6.3764,6.3764,3.3764
+Andrey Santos,49.566,0.1425,0.0648,5.4552,9.1263,0.3535,0.0,5.1698,5.1698,5.1698,5.1698,2.1698
+Soungoutou Magassa,48.5963,0.0379,0.033,5.8709,10.5145,0.2782,0.0221,5.0851,5.0851,5.0851,5.0851,2.0851
+Lucas Bergvall,47.0821,0.0997,0.0397,3.5438,6.8469,0.1322,0.0,5.5429,5.5429,5.5429,5.5429,2.5429
+Eliezer Mayenda,42.5331,0.24,0.0339,1.498,3.2026,0.0254,0.0,3.809,3.809,3.809,3.809,0.809
+Jair Cunha,78.2609,0.0296,0.0234,5.3585,7.6989,0.0,0.0,8.9667,8.9667,8.9667,8.9667,2.9667
+Quilindschy Hartman,83.8798,0.0203,0.1325,6.1767,10.3337,0.0543,0.0,10.8879,10.8879,10.8879,10.8879,4.8879
+Thierno Barry,54.7965,0.3265,0.0305,1.624,2.9763,0.1461,0.0,1.4231,1.4231,1.4231,1.4231,-1.5769
+Josh Acheampong,41.4493,0.0647,0.0103,3.3667,5.5666,0.1078,0.0,5.8245,5.8245,5.8245,5.8245,2.8245
+Yankuba Minteh,66.6667,0.1704,0.1841,3.6228,7.3012,0.1046,0.0,11.1513,11.1513,11.1513,11.1513,5.1513
+Myles Lewis-Skelly,27.1483,0.0028,0.0135,3.0567,5.8486,0.6636,0.0255,4.6424,4.6424,4.6424,4.6424,1.6424
+Jorrel Hato,45.6886,0.0241,0.0773,5.4521,8.9835,0.5255,0.0,5.5977,5.5977,5.5977,5.5977,2.5977
+Max Alleyne,67.6812,0.0181,0.0111,4.8975,6.9992,0.0876,0.0,8.5682,8.5682,8.5682,8.5682,2.5682
+Joshua King,39.687,0.1127,0.0257,1.7447,4.1208,0.1371,0.0,4.5216,4.5216,4.5216,4.5216,1.5216
+Stefanos Tzimas,65.0662,0.3403,0.0715,0.7995,2.4534,0.1369,0.0214,6.1438,6.1438,6.1438,6.1438,0.1438
+Enock Agyei,36.087,0.0114,0.008,0.3475,1.5197,0.0,0.0,3.0862,3.0862,3.0862,3.0862,0.0862
+Mamadou Sarr,82.8463,0.0204,0.0115,5.8743,10.2864,0.1702,0.0,8.8205,8.8205,8.8205,8.8205,2.8205
+Michael Kayode,81.3504,0.0231,0.0846,5.7577,10.3235,0.2103,0.0,11.1479,11.1479,11.1479,11.1479,5.1479
+Andrés García,39.3789,0.0083,0.0595,3.5976,6.7248,0.0,0.0,7.5357,7.5357,7.5357,7.5357,4.5357
+Malick Diouf,79.3391,0.0275,0.0605,5.3465,8.3409,0.1667,0.0,9.4961,9.4961,9.4961,9.4961,3.4961
+Murillo,87.2138,0.032,0.0234,8.7374,13.1184,0.1774,0.0,11.331,11.331,11.331,11.331,5.331
+Junior Kroupi,47.2251,0.2823,0.0467,2.9825,5.9706,0.1474,0.0,5.6279,5.6279,5.6279,5.6279,2.6279
+James Wilson,46.3406,0.1614,0.0851,1.3494,2.2801,0.0436,0.0436,3.3639,3.3639,3.3639,3.3639,0.3639
+Rayan,78.9209,0.1978,0.1078,3.3234,6.1355,0.1375,0.0,10.1546,10.1546,10.1546,10.1546,4.1546
+Patrick Dorgu,63.2964,0.0914,0.0816,4.7119,8.3529,0.22,0.0076,8.876,8.876,8.876,8.876,2.876
+Álex Jiménez,69.9209,0.0469,0.0511,5.0965,9.0096,0.3132,0.0,9.533,9.533,9.533,9.533,3.533
+Harrison Armstrong,58.9689,0.0364,0.0312,3.5776,6.5468,0.1578,0.0,4.9258,4.9258,4.9258,4.9258,1.9258
+Ayden Heaven,40.559,0.0318,0.0159,6.3629,9.3591,0.187,0.0,5.4968,5.4968,5.4968,5.4968,2.4968
+Charalampos Kostoulas,15.9783,0.2464,0.0102,2.2866,4.065,0.0,0.0,3.2117,3.2117,3.2117,3.2117,0.2117
+Adam Aznou,51.5362,0.0198,0.0075,3.8672,7.0893,0.0784,0.0,5.0892,5.0892,5.0892,5.0892,2.0892
+Christantus Uche,31.8291,0.2331,0.0864,1.5818,3.6167,0.1936,0.0053,1.905,1.905,1.905,1.905,-1.095
+Estêvão,43.0435,0.2243,0.1664,2.6617,5.8927,0.2848,0.0,7.1788,7.1788,7.1788,7.1788,4.1788
+Giovanni Leoni,61.5345,0.0116,0.001,4.2887,5.8787,0.1515,0.0505,7.9432,7.9432,7.9432,7.9432,1.9432
+Mateus Mané,55.7391,0.0556,0.0656,1.8953,4.0527,0.0,0.0,4.8833,4.8833,4.8833,4.8833,1.8833
+Nicolò Savona,71.7671,0.086,0.0314,3.6126,5.7055,0.1586,0.0,8.5127,8.5127,8.5127,8.5127,2.5127
+Milan Aleksic,31.3043,0.0303,0.0127,0.8607,1.8096,0.0505,0.0,3.7423,3.7423,3.7423,3.7423,0.7423
+Souza,59.4203,0.0392,0.0459,3.9552,6.2499,0.1446,0.0,5.669,5.669,5.669,5.669,2.669
+Alysson Edward,48.4993,0.1025,0.0419,2.6552,4.799,0.2144,0.0,4.0441,4.0441,4.0441,4.0441,1.0441
+Jaydee Canvot,59.2536,0.06,0.019,7.4195,10.4194,0.2124,0.0,5.5089,5.5089,5.5089,5.5089,2.5089
+Veljko Milosavljevic,45.5901,0.025,0.0317,5.6644,7.8302,0.0,0.0,5.8044,5.8044,5.8044,5.8044,2.8044
diff --git a/statistical_weighted_baselines_gk.csv b/statistical_weighted_baselines_gk.csv
new file mode 100644
index 0000000000000000000000000000000000000000..8966ef69bfaa1521ce7f5c3718e44b7f5f3c431a
--- /dev/null
+++ b/statistical_weighted_baselines_gk.csv
@@ -0,0 +1,54 @@
+player_name,baseline_xMins,baseline_xSaves_p90,baseline_xA_p90,baseline_yc_p90,baseline_rc_p90,baseline_pksave_p90,baseline_gk_bps_p90,baseline_bps_floor_p90
+Lukasz Fabianski,81.5161,3.7797,0.0,0.1072,0.0,0.0022,8.7647,2.7647
+John Ruddy,89.8423,2.9198,0.0024,0.0361,0.0,0.0105,9.2519,3.2519
+Martin Dúbravka,90.0,3.3718,0.0009,0.0252,0.0,0.0034,9.2175,3.2175
+Fraser Forster,89.5807,3.3368,0.0,0.0166,0.0,0.0166,8.1673,2.1673
+Jason Steele,90.0,2.2652,0.0022,0.0149,0.0,0.0149,8.7011,2.7011
+Karl Darlow,90.0,2.1308,0.0018,0.0895,0.0,0.0,9.3762,3.3762
+Simon Moore,90.0,1.9512,0.0,0.1694,0.0,0.0,9.1809,3.1809
+Matz Sels,85.5435,2.9536,0.0036,0.0911,0.0,0.0,8.6653,2.6653
+Daniel Bentley,78.1739,1.9216,0.0,0.0,0.0,0.0,7.9909,1.9909
+Marco Bizot,82.1739,2.8014,0.0002,0.3387,0.0023,0.0106,8.7602,2.7602
+Benjamin Lecomte,89.2174,3.5556,0.0016,0.0103,0.0026,0.0357,8.7255,2.7255
+Alphonse Areola,89.5936,3.7461,0.0,0.0025,0.0,0.005,8.7468,2.7468
+Bernd Leno,90.0,2.6904,0.0002,0.1029,0.0,0.0066,9.141,3.141
+Václav Hladky,78.242,1.6942,0.0022,0.0589,0.0,0.0,8.2933,2.2933
+Emiliano Martínez,88.0748,2.8527,0.0019,0.0964,0.0063,0.0326,9.2093,3.2093
+Stefan Ortega,89.2876,2.737,0.0023,0.0183,0.0,0.0,7.4951,1.4951
+Sam Johnstone,90.0,3.16,0.0011,0.0064,0.0,0.0,9.301,3.301
+Nick Pope,89.4862,3.0524,0.0,0.054,0.0007,0.0093,9.6859,3.6859
+Jordan Pickford,90.0,2.9164,0.0059,0.0987,0.0,0.0343,9.3661,3.3661
+Kepa Arrizabalaga,89.413,2.8622,0.0007,0.085,0.0,0.0,8.8415,2.8415
+Alisson Becker,89.9488,2.4353,0.0024,0.0304,0.0,0.0007,9.411,3.411
+José Sá,89.9955,2.6995,0.0011,0.0903,0.0,0.0168,9.7735,3.7735
+Walter Benítez,88.8293,1.8642,0.0029,0.0118,0.0,0.0,8.4906,2.4906
+Guglielmo Vicario,90.0,2.7397,0.0009,0.0375,0.0,0.0008,9.1905,3.1905
+Remi Matthews,78.2609,1.7934,0.0008,0.0399,0.0,0.0,8.2351,2.2351
+David Raya,90.0,1.8047,0.0019,0.0448,0.0,0.0023,9.3015,3.3015
+Freddie Woodman,89.9765,2.4971,0.0004,0.13,0.0183,0.0183,9.4773,3.4773
+Gianluigi Donnarumma,89.6304,2.4607,0.0,0.181,0.0031,0.0288,8.8206,2.8206
+Lucas Perri,90.0,2.7199,0.0002,0.0999,0.0,0.0,8.5959,2.5959
+Dean Henderson,90.0,2.9357,0.0023,0.0987,0.0,0.032,9.2588,3.2588
+Mark Travers,90.0,3.6092,0.0006,0.0308,0.0,0.0,8.8755,2.8755
+Aaron Ramsdale,83.3043,2.6602,0.0004,0.0896,0.0,0.0149,9.1422,3.1422
+John Victor,87.913,1.7653,0.0,0.1748,0.0,0.0022,8.3193,2.3193
+Angus Gunn,88.6739,2.4823,0.0002,0.0275,0.0,0.0025,9.1523,3.1523
+Caoimhín Kelleher,90.0,2.6642,0.0048,0.0226,0.0,0.0901,8.8585,2.8585
+Robert Sánchez,87.4513,2.8944,0.0011,0.143,0.0241,0.0127,9.3817,3.3817
+Ellery Balcombe,78.2609,1.8477,0.0027,0.0411,0.0,0.0616,8.6416,2.6416
+Hákon Rafn Valdimarsson,88.1709,2.3451,0.0002,0.0,0.0239,0.0,9.7967,3.7967
+Altay Bayindir,90.0,2.0842,0.0058,0.0057,0.0,0.0029,8.888,2.888
+Christos Mandas,88.7101,2.1475,0.0023,0.0,0.0,0.0,8.963,2.963
+Giorgi Mamardashvili,90.0,3.2707,0.0002,0.0212,0.002,0.1322,8.6423,2.6423
+Illan Meslier,89.8973,1.7575,0.0004,0.0258,0.0048,0.0174,8.6683,2.6683
+Mads Hermansen,89.7826,3.341,0.0012,0.0118,0.0,0.0101,9.4272,3.4272
+Gaga Slonina,90.0,3.2419,0.0002,0.0411,0.0,0.0411,9.0207,3.0207
+Djordje Petrovic,90.0,3.188,0.0002,0.0649,0.0,0.0083,9.2128,3.2128
+Robin Roefs,90.1186,3.0496,0.0034,0.0726,0.0,0.0242,9.8421,3.8421
+Bart Verbruggen,90.0,2.789,0.0014,0.1135,0.0,0.0219,9.1107,3.1107
+Senne Lammens,90.0,2.8107,0.0003,0.0055,0.0,0.0452,8.9024,2.9024
+Melker Ellborg,90.0,2.5778,0.0048,0.0319,0.0,0.0,9.9784,3.9784
+James Trafford,90.0,3.2035,0.0015,0.0451,0.0,0.0099,10.1739,4.1739
+Filip Jörgensen,88.2609,2.4271,0.0,0.0083,0.0,0.0,8.4981,2.4981
+Max Weiss,78.2609,2.2517,0.0002,0.0598,0.0,0.0199,8.6967,2.6967
+Antonín Kinsky,78.2609,2.71,0.0011,0.0,0.0,0.0,9.2558,3.2558
diff --git a/team_ratings_dual_speed.csv b/team_ratings_dual_speed.csv
new file mode 100644
index 0000000000000000000000000000000000000000..e62010338d5835b3f15895631b30df8f3f9830b7
--- /dev/null
+++ b/team_ratings_dual_speed.csv
@@ -0,0 +1,21 @@
+Team,Attack,Defence,Diff
+Arsenal,1.66,0.76,0.9
+Manchester City,1.73,0.96,0.77
+Liverpool,1.61,1.13,0.48
+Chelsea,1.61,1.16,0.46
+Manchester United,1.46,1.19,0.27
+Newcastle United,1.45,1.29,0.16
+Brighton and Hove Albion,1.32,1.17,0.15
+Brentford,1.37,1.26,0.11
+Aston Villa,1.26,1.2,0.06
+AFC Bournemouth,1.38,1.35,0.03
+Crystal Palace,1.17,1.2,-0.04
+Everton,1.08,1.11,-0.04
+Fulham,1.24,1.31,-0.07
+Nottingham Forest,1.07,1.24,-0.16
+Leeds United,1.2,1.4,-0.2
+West Ham United,1.15,1.45,-0.3
+Tottenham Hotspur,1.2,1.53,-0.33
+Sunderland,0.87,1.31,-0.44
+Wolverhampton Wanderers,0.93,1.41,-0.48
+Burnley,0.87,1.73,-0.86
diff --git a/team_totals.xlsx b/team_totals.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..0e3b3670dc6275a547ebf64cf60a4c28f3b297cc
--- /dev/null
+++ b/team_totals.xlsx
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95bc1564798b6a98e8042a5cae8093d6d7024aaf8aeebc60eb86faea0f5659f7
+size 20972
diff --git a/user_baseline_overrides.json b/user_baseline_overrides.json
new file mode 100644
index 0000000000000000000000000000000000000000..c0101036d5434d172c58ae7c2f718686510aaaa8
--- /dev/null
+++ b/user_baseline_overrides.json
@@ -0,0 +1,1382 @@
+{
+ "238": {
+ "Avg_BPS": 16.5
+ },
+ "382": {
+ "baseline_xMins": 76.0
+ },
+ "235": {
+ "baseline_xMins": 78.0
+ },
+ "381": {
+ "baseline_xMins": 77.0
+ },
+ "255": {
+ "baseline_xMins": 0.0
+ },
+ "17": {
+ "Avg_BPS": 20.5,
+ "baseline_CBITR_p90": 1.3,
+ "baseline_xMins": 66.0
+ },
+ "173": {
+ "baseline_xMins": 82.0
+ },
+ "430": {
+ "baseline_xMins": 83.0
+ },
+ "336": {
+ "baseline_xMins": 10.0
+ },
+ "385": {
+ "baseline_xMins": 4.0
+ },
+ "422": {
+ "baseline_xMins": 0.0
+ },
+ "1": {
+ "Avg_BPS": 5.9,
+ "baseline_xSaves_p90": 1.0,
+ "baseline_pksave_p90": 0.0019999999999999983,
+ "baseline_xMins": 90.0
+ },
+ "190": {
+ "baseline_xMins": 38.0
+ },
+ "195": {
+ "baseline_xMins": 58.0
+ },
+ "199": {
+ "baseline_xMins": 21.0
+ },
+ "5": {
+ "Avg_BPS": 18.3,
+ "baseline_xMins": 86.0
+ },
+ "50": {
+ "baseline_xMins": 69.0
+ },
+ "16": {
+ "Avg_BPS": 26.0,
+ "baseline_xMins": 72.0
+ },
+ "164": {
+ "baseline_xMins": 8.0
+ },
+ "168": {
+ "baseline_xMins": 5.0
+ },
+ "169": {
+ "baseline_xMins": 71.0
+ },
+ "299": {
+ "baseline_xMins": 86.0
+ },
+ "666": {
+ "Avg_BPS": 26.7,
+ "baseline_xMins": 67.0
+ },
+ "266": {
+ "Avg_BPS": 21.9,
+ "baseline_xMins": 54.0
+ },
+ "268": {
+ "baseline_xMins": 2.0
+ },
+ "64": {
+ "Avg_BPS": 25.3,
+ "baseline_xMins": 70.0
+ },
+ "370": {
+ "Avg_BPS": 21.6,
+ "baseline_xMins": 68.0
+ },
+ "376": {
+ "baseline_xMins": 55.0
+ },
+ "705": {
+ "baseline_xMins": 0.0
+ },
+ "709": {
+ "baseline_xMins": 87.0
+ },
+ "449": {
+ "baseline_xMins": 88.0
+ },
+ "442": {
+ "baseline_xMins": 84.0
+ },
+ "300": {
+ "Avg_BPS": 20.5,
+ "baseline_xMins": 24.0
+ },
+ "303": {
+ "baseline_xMins": 89.0
+ },
+ "387": {
+ "baseline_xMins": 87.0
+ },
+ "267": {
+ "baseline_xMins": 83.0
+ },
+ "48": {
+ "baseline_xG_p90": 1.0,
+ "baseline_xMins": 76.0
+ },
+ "386": {
+ "baseline_xMins": 75.0
+ },
+ "257": {
+ "baseline_CBIT_p90": 1.0,
+ "baseline_xMins": 89.0
+ },
+ "570": {
+ "baseline_xMins": 63.0
+ },
+ "541": {
+ "Avg_BPS": 17.9,
+ "baseline_xMins": 84.0
+ },
+ "258": {
+ "Avg_BPS": 17.2,
+ "baseline_xMins": 81.0
+ },
+ "291": {
+ "baseline_xMins": 89.0
+ },
+ "292": {
+ "baseline_xMins": 72.0
+ },
+ "294": {
+ "baseline_xMins": 10.0
+ },
+ "568": {
+ "baseline_CBIT_p90": 1.0,
+ "baseline_xMins": 82.0
+ },
+ "551": {
+ "baseline_xMins": 24.0
+ },
+ "550": {
+ "baseline_xMins": 0.0
+ },
+ "535": {
+ "baseline_xMins": 25.0
+ },
+ "8": {
+ "baseline_xMins": 84.0
+ },
+ "85": {
+ "baseline_xMins": 68.0
+ },
+ "18": {
+ "Avg_BPS": 16.5,
+ "baseline_xG_p90": 1.0,
+ "baseline_xA_p90": 1.0,
+ "baseline_xMins": 31.0
+ },
+ "180": {
+ "baseline_xMins": 0.0
+ },
+ "19": {
+ "Avg_BPS": 20.5,
+ "baseline_xG_p90": 0.8,
+ "baseline_xA_p90": 0.7
+ },
+ "22": {
+ "baseline_xG_p90": 0.75,
+ "baseline_xA_p90": 0.85,
+ "baseline_CBITR_p90": 0.8
+ },
+ "24": {
+ "baseline_xMins": 12.0
+ },
+ "30": {
+ "Avg_BPS": 22.7,
+ "baseline_xMins": 54.0
+ },
+ "38": {
+ "baseline_rc_p90": 0.0
+ },
+ "47": {
+ "Avg_BPS": 23.0764
+ },
+ "67": {
+ "baseline_pksave_p90": 0.011,
+ "baseline_xMins": 89.0
+ },
+ "72": {
+ "baseline_xMins": 89.0
+ },
+ "74": {
+ "Avg_BPS": 24.1,
+ "baseline_CBIT_p90": 1.0
+ },
+ "721": {
+ "baseline_xMins": 12.0
+ },
+ "81": {
+ "baseline_xG_p90": 1.0,
+ "baseline_xMins": 68.0
+ },
+ "90": {
+ "baseline_xMins": 75.0
+ },
+ "97": {
+ "baseline_xMins": 78.0,
+ "baseline_xG_p90": 1.0
+ },
+ "98": {
+ "Avg_BPS": 22.7,
+ "baseline_xMins": 10.0
+ },
+ "101": {
+ "baseline_pksave_p90": 0.03,
+ "baseline_xMins": 90.0
+ },
+ "105": {
+ "baseline_xMins": 0.0
+ },
+ "111": {
+ "baseline_xG_p90": 0.5,
+ "baseline_xMins": 25.0
+ },
+ "136": {
+ "baseline_xMins": 82.0
+ },
+ "143": {
+ "baseline_xMins": 14.0
+ },
+ "149": {
+ "baseline_xMins": 0.0
+ },
+ "151": {
+ "baseline_xMins": 87.0
+ },
+ "160": {
+ "baseline_xMins": 52.0
+ },
+ "123": {
+ "Avg_BPS": 22.3
+ },
+ "206": {
+ "Avg_BPS": 24.9,
+ "baseline_xMins": 52.0
+ },
+ "224": {
+ "Avg_BPS": 17.9,
+ "baseline_xMins": 75.0
+ },
+ "229": {
+ "baseline_xMins": 24.0
+ },
+ "239": {
+ "Avg_BPS": 24.1
+ },
+ "283": {
+ "baseline_xG_p90": 1.0,
+ "baseline_xMins": 35.0
+ },
+ "242": {
+ "baseline_xMins": 87.0
+ },
+ "244": {
+ "baseline_xMins": 19.0
+ },
+ "667": {
+ "Avg_BPS": 16.8,
+ "baseline_xMins": 5.0
+ },
+ "290": {
+ "baseline_xMins": 78.0
+ },
+ "329": {
+ "baseline_xMins": 83.0
+ },
+ "337": {
+ "baseline_xG_p90": 1.0,
+ "baseline_xMins": 64.0
+ },
+ "325": {
+ "baseline_xMins": 64.0
+ },
+ "324": {
+ "baseline_xMins": 87.0
+ },
+ "343": {
+ "baseline_xG_p90": 0.5,
+ "baseline_xMins": 85.0
+ },
+ "347": {
+ "baseline_xMins": 88.0
+ },
+ "362": {
+ "baseline_xMins": 2.0
+ },
+ "365": {
+ "baseline_xMins": 48.0,
+ "baseline_xG_p90": 0.9
+ },
+ "380": {
+ "baseline_xMins": 0.0
+ },
+ "390": {
+ "Avg_BPS": 19.0
+ },
+ "403": {
+ "baseline_xG_p90": 0.65,
+ "baseline_xMins": 83.0
+ },
+ "409": {
+ "baseline_xMins": 0.0
+ },
+ "436": {
+ "baseline_xG_p90": 0.5,
+ "baseline_xMins": 0.0
+ },
+ "437": {
+ "baseline_xMins": 86.0
+ },
+ "438": {
+ "baseline_xMins": 15.0
+ },
+ "441": {
+ "baseline_xG_p90": 1.05,
+ "baseline_xA_p90": 1.0,
+ "baseline_xMins": 85.0,
+ "baseline_CBIT_p90": 1.15,
+ "baseline_rc_p90": 0.0
+ },
+ "447": {
+ "baseline_xMins": 4.0
+ },
+ "469": {
+ "baseline_pksave_p90": 0.02,
+ "baseline_xMins": 2.0
+ },
+ "516": {
+ "baseline_xMins": 73.0
+ },
+ "517": {
+ "Avg_BPS": 28.9,
+ "baseline_xMins": 84.0
+ },
+ "565": {
+ "baseline_xSaves_p90": 1.24,
+ "baseline_pksave_p90": 0.019999999999999997,
+ "baseline_yc_p90": 0.5
+ },
+ "569": {
+ "baseline_CBIT_p90": 1.0,
+ "baseline_rc_p90": 0.0,
+ "baseline_xMins": 85.0
+ },
+ "571": {
+ "baseline_xMins": 15.0
+ },
+ "572": {
+ "baseline_xMins": 10.0
+ },
+ "573": {
+ "baseline_xMins": 35.0
+ },
+ "582": {
+ "baseline_rc_p90": 0.0
+ },
+ "531": {
+ "baseline_xMins": 83.0,
+ "baseline_CBIT_p90": 0.9
+ },
+ "532": {
+ "Avg_BPS": 15.0,
+ "baseline_CBIT_p90": 0.8
+ },
+ "543": {
+ "baseline_xG_p90": 0.8,
+ "baseline_xA_p90": 0.75,
+ "baseline_CBITR_p90": 0.8
+ },
+ "444": {
+ "baseline_xMins": 76.0
+ },
+ "544": {
+ "baseline_xMins": 82.0
+ },
+ "552": {
+ "baseline_xA_p90": 1.0,
+ "baseline_xG_p90": 1.0,
+ "Avg_BPS": 18.55,
+ "baseline_CBITR_p90": 0.85
+ },
+ "553": {
+ "Avg_BPS": 24.1,
+ "baseline_xG_p90": 0.5,
+ "baseline_xA_p90": 1.0,
+ "baseline_CBITR_p90": 0.8
+ },
+ "561": {
+ "Avg_BPS": 20.7,
+ "baseline_xG_p90": 1.0,
+ "baseline_xA_p90": 0.7,
+ "baseline_xMins": 26.0
+ },
+ "668": {
+ "baseline_xA_p90": 0.8,
+ "baseline_xG_p90": 0.5,
+ "baseline_rc_p90": 2.0,
+ "Avg_BPS": 19.2605
+ },
+ "628": {
+ "baseline_xMins": 90.0
+ },
+ "629": {
+ "baseline_xMins": 0.0
+ },
+ "646": {
+ "baseline_xMins": 83.0
+ },
+ "644": {
+ "baseline_xMins": 25.0
+ },
+ "677": {
+ "baseline_xMins": 64.0
+ },
+ "54": {
+ "baseline_xA_p90": 0.7,
+ "baseline_CBITR_p90": 0.7
+ },
+ "596": {
+ "Avg_BPS": 29.7,
+ "baseline_xMins": 67.0
+ },
+ "261": {
+ "baseline_xMins": 89.0
+ },
+ "262": {
+ "baseline_xMins": 11.0
+ },
+ "270": {
+ "baseline_xMins": 65.0
+ },
+ "272": {
+ "baseline_xMins": 63.0
+ },
+ "273": {
+ "baseline_xMins": 75.0
+ },
+ "135": {
+ "baseline_xMins": 23.0
+ },
+ "252": {
+ "Avg_BPS": 15.8,
+ "baseline_xMins": 25.0
+ },
+ "679": {
+ "baseline_pksave_p90": 0.02,
+ "baseline_xMins": 85.0
+ },
+ "685": {
+ "baseline_yc_p90": 0.5,
+ "baseline_CBIT_p90": 1.0,
+ "baseline_xMins": 12.0
+ },
+ "652": {
+ "baseline_xMins": 0.0
+ },
+ "658": {
+ "baseline_xMins": 2.0
+ },
+ "683": {
+ "baseline_xMins": 86.0
+ },
+ "20": {
+ "baseline_xMins": 62.0
+ },
+ "40": {
+ "baseline_xMins": 56.0
+ },
+ "44": {
+ "baseline_xMins": 36.0
+ },
+ "59": {
+ "baseline_xMins": 69.0
+ },
+ "431": {
+ "baseline_pksave_p90": 0.0,
+ "baseline_xMins": 0.0
+ },
+ "694": {
+ "baseline_xMins": 86.0
+ },
+ "735": {
+ "baseline_xMins": 20.0
+ },
+ "734": {
+ "baseline_xMins": 18.0
+ },
+ "698": {
+ "baseline_xG_p90": 0.7,
+ "baseline_xA_p90": 0.8,
+ "baseline_xMins": 65.0
+ },
+ "125": {
+ "baseline_xMins": 70.0
+ },
+ "126": {
+ "baseline_xMins": 73.0
+ },
+ "226": {
+ "baseline_xMins": 87.0
+ },
+ "249": {
+ "baseline_xG_p90": 1.0,
+ "baseline_rc_p90": 0.0,
+ "baseline_xMins": 84.0
+ },
+ "205": {
+ "baseline_CBITR_p90": 0.8,
+ "baseline_xMins": 0.0
+ },
+ "145": {
+ "baseline_CBIT_p90": 1.0,
+ "baseline_xMins": 48.0
+ },
+ "148": {
+ "baseline_xMins": 87.0
+ },
+ "700": {
+ "baseline_xG_p90": 0.4
+ },
+ "414": {
+ "baseline_CBITR_p90": 1.0,
+ "baseline_xMins": 44.0,
+ "baseline_yc_p90": 0.5
+ },
+ "736": {
+ "baseline_pksave_p90": 0.01,
+ "baseline_xMins": 90.0
+ },
+ "733": {
+ "baseline_pksave_p90": 0.02,
+ "baseline_xMins": 90.0
+ },
+ "547": {
+ "baseline_xMins": 85.0,
+ "baseline_xG_p90": 0.9
+ },
+ "457": {
+ "baseline_xMins": 76.0
+ },
+ "458": {
+ "baseline_xMins": 79.0
+ },
+ "459": {
+ "baseline_xMins": 12.0
+ },
+ "660": {
+ "baseline_xMins": 82.0
+ },
+ "342": {
+ "baseline_xG_p90": 0.5,
+ "baseline_xA_p90": 0.4,
+ "baseline_xMins": 68.0
+ },
+ "411": {
+ "baseline_xMins": 73.0
+ },
+ "6": {
+ "baseline_xMins": 85.0,
+ "baseline_CBIT_p90": 1.0
+ },
+ "32": {
+ "baseline_yc_p90": 0.5,
+ "baseline_pksave_p90": 0.02,
+ "baseline_xMins": 90.0
+ },
+ "157": {
+ "baseline_xMins": 79.0
+ },
+ "159": {
+ "baseline_xMins": 0.0
+ },
+ "198": {
+ "baseline_xMins": 75.0
+ },
+ "200": {
+ "baseline_xMins": 64.0
+ },
+ "217": {
+ "baseline_xMins": 46.0
+ },
+ "470": {
+ "baseline_xMins": 90.0,
+ "baseline_pksave_p90": 0.009286999999999998
+ },
+ "220": {
+ "baseline_xMins": 88.0,
+ "baseline_pksave_p90": 0.014733999999999999
+ },
+ "221": {
+ "baseline_xMins": 20.0
+ },
+ "712": {
+ "baseline_xMins": 56.0
+ },
+ "717": {
+ "baseline_xMins": 74.0
+ },
+ "549": {
+ "baseline_xMins": 0.0
+ },
+ "419": {
+ "baseline_xMins": 0.0,
+ "baseline_xA_p90": 0.8,
+ "baseline_xG_p90": 0.6
+ },
+ "413": {
+ "baseline_xMins": 45.0
+ },
+ "691": {
+ "baseline_xMins": 83.0
+ },
+ "367": {
+ "baseline_pksave_p90": 0.021512999999999997,
+ "baseline_xMins": 2.0
+ },
+ "407": {
+ "baseline_xMins": 83.0
+ },
+ "418": {
+ "baseline_xMins": 61.0
+ },
+ "450": {
+ "baseline_xMins": 80.0
+ },
+ "681": {
+ "baseline_xMins": 53.0
+ },
+ "682": {
+ "baseline_xMins": 32.0
+ },
+ "615": {
+ "baseline_xMins": 82.0
+ },
+ "485": {
+ "baseline_xMins": 77.0
+ },
+ "491": {
+ "baseline_xG_p90": 0.4
+ },
+ "488": {
+ "baseline_xG_p90": 0.6
+ },
+ "714": {
+ "baseline_xMins": 63.0
+ },
+ "675": {
+ "baseline_xMins": 6.0
+ },
+ "597": {
+ "baseline_xMins": 62.0
+ },
+ "673": {
+ "baseline_xMins": 82.0
+ },
+ "560": {
+ "baseline_xMins": 35.0
+ },
+ "620": {
+ "baseline_xMins": 14.0
+ },
+ "624": {
+ "baseline_xMins": 89.0
+ },
+ "627": {
+ "baseline_xMins": 4.0
+ },
+ "632": {
+ "baseline_xMins": 28.0
+ },
+ "633": {
+ "baseline_xMins": 74.0
+ },
+ "634": {
+ "baseline_xMins": 81.0
+ },
+ "635": {
+ "baseline_xMins": 57.0
+ },
+ "209": {
+ "baseline_xMins": 30.0
+ },
+ "216": {
+ "baseline_xMins": 3.0
+ },
+ "525": {
+ "baseline_xMins": 13.0
+ },
+ "637": {
+ "baseline_xMins": 37.0
+ },
+ "648": {
+ "baseline_xMins": 0.0
+ },
+ "493": {
+ "baseline_xMins": 27.0
+ },
+ "338": {
+ "baseline_xMins": 44.0
+ },
+ "335": {
+ "baseline_xMins": 38.0,
+ "baseline_xA_p90": 2.0,
+ "baseline_xG_p90": 1.5
+ },
+ "476": {
+ "baseline_xMins": 78.0
+ },
+ "479": {
+ "baseline_xMins": 0.0
+ },
+ "480": {
+ "baseline_xMins": 0.0
+ },
+ "7": {
+ "baseline_xMins": 43.0
+ },
+ "719": {
+ "baseline_xMins": 3.0
+ },
+ "77": {
+ "baseline_xMins": 85.0
+ },
+ "723": {
+ "baseline_xMins": 76.0
+ },
+ "725": {
+ "baseline_xMins": 59.0
+ },
+ "263": {
+ "baseline_xMins": 10.0
+ },
+ "158": {
+ "baseline_xMins": 42.0
+ },
+ "225": {
+ "baseline_xMins": 68.0
+ },
+ "302": {
+ "baseline_xMins": 73.0
+ },
+ "374": {
+ "baseline_xMins": 83.0
+ },
+ "384": {
+ "baseline_xMins": 68.0
+ },
+ "499": {
+ "baseline_xMins": 64.0
+ },
+ "182": {
+ "baseline_xMins": 2.0
+ },
+ "427": {
+ "baseline_xMins": 47.0
+ },
+ "423": {
+ "baseline_xMins": 41.0
+ },
+ "429": {
+ "baseline_xMins": 0.0
+ },
+ "475": {
+ "baseline_xMins": 64.0
+ },
+ "478": {
+ "baseline_xMins": 34.0
+ },
+ "600": {
+ "baseline_xMins": 14.0
+ },
+ "612": {
+ "baseline_xMins": 0.0
+ },
+ "636": {
+ "baseline_xMins": 74.0
+ },
+ "100": {
+ "baseline_xMins": 70.0,
+ "baseline_yc_p90": 0.4
+ },
+ "806": {
+ "baseline_xMins": 0.0
+ },
+ "807": {
+ "baseline_xMins": 83.0
+ },
+ "626": {
+ "baseline_xMins": 49.0
+ },
+ "178": {
+ "baseline_xMins": 73.0
+ },
+ "232": {
+ "baseline_xMins": 69.0
+ },
+ "230": {
+ "baseline_xMins": 68.0
+ },
+ "256": {
+ "baseline_xMins": 88.0
+ },
+ "264": {
+ "baseline_xMins": 0.0
+ },
+ "684": {
+ "baseline_xMins": 87.0,
+ "baseline_CBIT_p90": 1.0
+ },
+ "687": {
+ "baseline_xMins": 0.0
+ },
+ "467": {
+ "baseline_xMins": 8.0
+ },
+ "452": {
+ "baseline_xMins": 74.0
+ },
+ "804": {
+ "baseline_xMins": 14.0
+ },
+ "246": {
+ "baseline_xMins": 56.0
+ },
+ "237": {
+ "baseline_xMins": 72.0
+ },
+ "21": {
+ "baseline_xMins": 84.0
+ },
+ "83": {
+ "baseline_xMins": 78.0
+ },
+ "120": {
+ "baseline_xMins": 77.0
+ },
+ "12": {
+ "baseline_xMins": 0.0
+ },
+ "317": {
+ "baseline_xMins": 88.0
+ },
+ "417": {
+ "baseline_xMins": 68.0
+ },
+ "474": {
+ "baseline_xMins": 86.0
+ },
+ "506": {
+ "baseline_xMins": 85.0
+ },
+ "575": {
+ "baseline_xMins": 86.0
+ },
+ "2": {
+ "baseline_xMins": 1.0
+ },
+ "500": {
+ "baseline_xMins": 6.0
+ },
+ "662": {
+ "baseline_xMins": 24.0
+ },
+ "665": {
+ "baseline_xMins": 0.0
+ },
+ "33": {
+ "baseline_xMins": 0.0
+ },
+ "110": {
+ "baseline_xMins": 85.0
+ },
+ "11": {
+ "baseline_xMins": 15.0
+ },
+ "113": {
+ "baseline_CBIT_p90": 1.0,
+ "baseline_xMins": 77.0
+ },
+ "152": {
+ "baseline_xMins": 21.0
+ },
+ "672": {
+ "baseline_xMins": 37.0
+ },
+ "676": {
+ "baseline_xMins": 67.0
+ },
+ "722": {
+ "baseline_xMins": 55.0
+ },
+ "322": {
+ "baseline_xMins": 85.0
+ },
+ "73": {
+ "baseline_xMins": 22.0
+ },
+ "731": {
+ "baseline_xMins": 35.0
+ },
+ "344": {
+ "baseline_xMins": 81.0
+ },
+ "346": {
+ "baseline_xMins": 0.0
+ },
+ "373": {
+ "baseline_xMins": 86.0
+ },
+ "402": {
+ "baseline_xMins": 65.0
+ },
+ "526": {
+ "baseline_xMins": 66.0
+ },
+ "716": {
+ "baseline_xMins": 33.0
+ },
+ "166": {
+ "baseline_xMins": 43.0
+ },
+ "718": {
+ "baseline_xMins": 29.0
+ },
+ "727": {
+ "baseline_xMins": 65.0
+ },
+ "695": {
+ "baseline_xMins": 52.0
+ },
+ "215": {
+ "baseline_xMins": 64.0
+ },
+ "706": {
+ "baseline_xMins": 54.0
+ },
+ "625": {
+ "baseline_xMins": 23.0
+ },
+ "653": {
+ "baseline_xMins": 0.0
+ },
+ "649": {
+ "baseline_xMins": 0.0
+ },
+ "37": {
+ "baseline_xMins": 43.0
+ },
+ "39": {
+ "baseline_xMins": 51.0
+ },
+ "41": {
+ "baseline_xMins": 57.0
+ },
+ "247": {
+ "baseline_xMins": 10.0
+ },
+ "473": {
+ "baseline_xMins": 84.0
+ },
+ "487": {
+ "baseline_xMins": 65.0
+ },
+ "720": {
+ "baseline_xMins": 52.0
+ },
+ "82": {
+ "baseline_xMins": 82.0
+ },
+ "191": {
+ "baseline_xMins": 85.0
+ },
+ "192": {
+ "baseline_xMins": 55.0
+ },
+ "661": {
+ "baseline_xMins": 71.0
+ },
+ "106": {
+ "baseline_CBIT_p90": 1.0,
+ "baseline_xMins": 76.0
+ },
+ "284": {
+ "baseline_xMins": 21.0
+ },
+ "400": {
+ "baseline_xMins": 0.0
+ },
+ "446": {
+ "baseline_xMins": 0.0
+ },
+ "713": {
+ "baseline_xMins": 69.0
+ },
+ "121": {
+ "baseline_xMins": 68.0
+ },
+ "139": {
+ "baseline_xMins": 90.0
+ },
+ "27": {
+ "baseline_xMins": 6.0
+ },
+ "316": {
+ "baseline_xMins": 48.0
+ },
+ "408": {
+ "baseline_xMins": 85.0
+ },
+ "236": {
+ "baseline_xMins": 68.0
+ },
+ "295": {
+ "baseline_xMins": 34.0
+ },
+ "440": {
+ "baseline_xMins": 82.0
+ },
+ "455": {
+ "baseline_xMins": 22.0
+ },
+ "699": {
+ "baseline_xMins": 68.0
+ },
+ "497": {
+ "baseline_xMins": 34.0
+ },
+ "107": {
+ "baseline_xMins": 53.0
+ },
+ "153": {
+ "baseline_xMins": 0.0
+ },
+ "415": {
+ "baseline_xMins": 22.0
+ },
+ "416": {
+ "baseline_xMins": 53.0
+ },
+ "310": {
+ "baseline_xMins": 71.0
+ },
+ "311": {
+ "baseline_xMins": 48.0
+ },
+ "287": {
+ "baseline_pksave_p90": 0.03
+ },
+ "119": {
+ "baseline_xMins": 84.0
+ },
+ "276": {
+ "baseline_xMins": 16.0
+ },
+ "654": {
+ "baseline_xMins": 75.0
+ },
+ "749": {
+ "baseline_xMins": 84.0
+ },
+ "730": {
+ "baseline_xMins": 68.0
+ },
+ "671": {
+ "baseline_xMins": 24.0
+ },
+ "674": {
+ "baseline_xMins": 87.0
+ },
+ "108": {
+ "baseline_xMins": 45.0
+ },
+ "580": {
+ "baseline_xMins": 42.0
+ },
+ "350": {
+ "baseline_xMins": 71.0
+ },
+ "84": {
+ "baseline_xMins": 85.0
+ },
+ "783": {
+ "baseline_xMins": 86.0
+ },
+ "728": {
+ "baseline_xMins": 23.0
+ },
+ "328": {
+ "baseline_xMins": 64.0
+ },
+ "320": {
+ "baseline_xMins": 43.0
+ },
+ "321": {
+ "baseline_xMins": 23.0
+ },
+ "791": {
+ "baseline_xMins": 80.0
+ },
+ "785": {
+ "baseline_xMins": 53.0
+ },
+ "642": {
+ "baseline_xMins": 65.0
+ },
+ "643": {
+ "baseline_xMins": 84.0
+ },
+ "36": {
+ "baseline_xMins": 86.0
+ },
+ "794": {
+ "baseline_xMins": 10.0
+ },
+ "613": {
+ "baseline_xMins": 75.0
+ },
+ "614": {
+ "baseline_xMins": 71.0
+ },
+ "726": {
+ "baseline_xMins": 54.0
+ },
+ "796": {
+ "baseline_xMins": 71.0
+ },
+ "792": {
+ "baseline_xMins": 13.0
+ },
+ "260": {
+ "baseline_xMins": 78.0
+ },
+ "697": {
+ "baseline_xMins": 54.0
+ },
+ "10": {
+ "baseline_xMins": 16.0
+ },
+ "128": {
+ "baseline_xMins": 5.0
+ },
+ "109": {
+ "baseline_xMins": 70.0
+ },
+ "138": {
+ "baseline_xMins": 0.0
+ },
+ "185": {
+ "baseline_xMins": 0.0
+ },
+ "288": {
+ "baseline_xMins": 0.0
+ },
+ "341": {
+ "baseline_xMins": 88.0
+ },
+ "510": {
+ "baseline_xMins": 20.0
+ },
+ "511": {
+ "baseline_xMins": 31.0
+ },
+ "529": {
+ "baseline_xMins": 0.0
+ },
+ "52": {
+ "baseline_xMins": 69.0
+ },
+ "566": {
+ "baseline_xMins": 0.0
+ },
+ "567": {
+ "baseline_xMins": 0.0
+ },
+ "753": {
+ "baseline_xMins": 0.0
+ },
+ "68": {
+ "baseline_xMins": 0.0
+ },
+ "254": {
+ "baseline_xMins": 0.0
+ },
+ "259": {
+ "baseline_xMins": 23.0
+ },
+ "664": {
+ "baseline_xMins": 0.0
+ },
+ "782": {
+ "baseline_xMins": 0.0
+ },
+ "715": {
+ "baseline_xMins": 0.0
+ },
+ "31": {
+ "baseline_xMins": 36.0
+ },
+ "808": {
+ "baseline_xMins": 35.0
+ },
+ "817": {
+ "baseline_xMins": 61.0,
+ "baseline_xG_p90": 0.4
+ },
+ "818": {
+ "baseline_xMins": 0.0
+ },
+ "815": {
+ "baseline_xMins": 74.0
+ },
+ "814": {
+ "baseline_xMins": 25.0
+ },
+ "813": {
+ "baseline_xMins": 51.0
+ },
+ "812": {
+ "baseline_xMins": 0.0
+ },
+ "603": {
+ "baseline_xMins": 82.0
+ },
+ "605": {
+ "baseline_xMins": 15.0
+ },
+ "606": {
+ "baseline_xMins": 76.0
+ },
+ "608": {
+ "baseline_xMins": 23.0
+ },
+ "609": {
+ "baseline_xMins": 82.0
+ },
+ "623": {
+ "baseline_xMins": 15.0
+ },
+ "659": {
+ "baseline_xMins": 27.0
+ },
+ "708": {
+ "baseline_xMins": 83.0
+ },
+ "738": {
+ "baseline_xMins": 0.0
+ },
+ "747": {
+ "baseline_xMins": 0.0
+ },
+ "231": {
+ "baseline_xMins": 32.0
+ },
+ "26": {
+ "baseline_xMins": 83.0
+ },
+ "163": {
+ "baseline_xMins": 65.0
+ },
+ "181": {
+ "baseline_xMins": 12.0
+ },
+ "801": {
+ "baseline_xMins": 4.0
+ },
+ "391": {
+ "baseline_xMins": 4.0
+ },
+ "183": {
+ "baseline_xMins": 0.0
+ },
+ "186": {
+ "baseline_xMins": 0.0
+ },
+ "187": {
+ "baseline_xMins": 77.0
+ },
+ "214": {
+ "baseline_xMins": 0.0
+ },
+ "218": {
+ "baseline_xMins": 10.0
+ },
+ "233": {
+ "baseline_xMins": 21.0
+ },
+ "339": {
+ "baseline_xMins": 0.0
+ },
+ "348": {
+ "baseline_xMins": 87.0
+ },
+ "354": {
+ "baseline_xMins": 77.0
+ },
+ "356": {
+ "baseline_xMins": 53.0
+ },
+ "366": {
+ "baseline_xMins": 90.0
+ },
+ "539": {
+ "baseline_xMins": 0.0
+ },
+ "554": {
+ "baseline_xMins": 0.0
+ },
+ "326": {
+ "baseline_xMins": 40.0
+ },
+ "210": {
+ "baseline_xMins": 16.0
+ },
+ "379": {
+ "baseline_xMins": 0.0
+ },
+ "388": {
+ "baseline_xMins": 30.0
+ },
+ "406": {
+ "baseline_xMins": 42.0
+ },
+ "410": {
+ "baseline_xMins": 16.0
+ },
+ "421": {
+ "baseline_xMins": 65.0
+ },
+ "448": {
+ "baseline_xMins": 0.0
+ },
+ "466": {
+ "baseline_xMins": 20.0
+ },
+ "477": {
+ "baseline_xMins": 79.0
+ },
+ "86": {
+ "baseline_xMins": 21.0
+ },
+ "88": {
+ "baseline_xMins": 48.0
+ },
+ "680": {
+ "baseline_xMins": 30.0
+ },
+ "250": {
+ "baseline_xMins": 20.0
+ },
+ "405": {
+ "baseline_xMins": 19.0
+ }
+}
\ No newline at end of file
diff --git a/user_player_status_overrides.json b/user_player_status_overrides.json
new file mode 100644
index 0000000000000000000000000000000000000000..44d0e224f669594e03ec046dfa6df84f363a852a
--- /dev/null
+++ b/user_player_status_overrides.json
@@ -0,0 +1,1054 @@
+{
+ "383": {
+ "status": "not_a_starter"
+ },
+ "579": {
+ "status": "not_a_starter"
+ },
+ "251": {
+ "status": "not_a_starter"
+ },
+ "257": {
+ "status": "default"
+ },
+ "589": {
+ "status": "not_a_starter"
+ },
+ "581": {
+ "status": "not_a_starter"
+ },
+ "97": {
+ "status": "default"
+ },
+ "583": {
+ "status": "not_a_starter"
+ },
+ "198": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "585": {
+ "status": "injured",
+ "weeks_out": 26
+ },
+ "586": {
+ "status": "injured",
+ "weeks_out": 35
+ },
+ "12": {
+ "status": "not_a_starter"
+ },
+ "13": {
+ "status": "not_a_starter"
+ },
+ "14": {
+ "status": "not_a_starter"
+ },
+ "15": {
+ "status": "not_a_starter"
+ },
+ "20": {
+ "status": "rotational_risk"
+ },
+ "27": {
+ "status": "default"
+ },
+ "28": {
+ "status": "not_a_starter"
+ },
+ "731": {
+ "status": "injured"
+ },
+ "29": {
+ "status": "not_a_starter"
+ },
+ "31": {
+ "status": "default"
+ },
+ "32": {
+ "status": "default"
+ },
+ "61": {
+ "status": "not_a_starter"
+ },
+ "66": {
+ "status": "not_a_starter"
+ },
+ "70": {
+ "status": "not_a_starter"
+ },
+ "71": {
+ "status": "not_a_starter"
+ },
+ "76": {
+ "status": "not_a_starter"
+ },
+ "75": {
+ "status": "not_a_starter"
+ },
+ "94": {
+ "status": "not_a_starter"
+ },
+ "99": {
+ "status": "not_a_starter"
+ },
+ "102": {
+ "status": "not_a_starter"
+ },
+ "103": {
+ "status": "not_a_starter"
+ },
+ "147": {
+ "status": "not_a_starter"
+ },
+ "216": {
+ "status": "default"
+ },
+ "215": {
+ "status": "injured",
+ "weeks_out": 23
+ },
+ "219": {
+ "status": "not_a_starter"
+ },
+ "223": {
+ "status": "not_a_starter"
+ },
+ "221": {
+ "status": "injured",
+ "weeks_out": 35
+ },
+ "226": {
+ "status": "injured",
+ "weeks_out": 34
+ },
+ "225": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "227": {
+ "status": "injured",
+ "weeks_out": 37
+ },
+ "224": {
+ "status": "default"
+ },
+ "240": {
+ "status": "not_a_starter"
+ },
+ "245": {
+ "status": "not_a_starter"
+ },
+ "397": {
+ "status": "not_a_starter"
+ },
+ "398": {
+ "status": "not_a_starter"
+ },
+ "412": {
+ "status": "not_a_starter"
+ },
+ "419": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "448": {
+ "status": "not_a_starter"
+ },
+ "488": {
+ "status": "injured",
+ "weeks_out": 31
+ },
+ "441": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "451": {
+ "status": "not_a_starter"
+ },
+ "453": {
+ "status": "default"
+ },
+ "454": {
+ "status": "not_a_starter"
+ },
+ "456": {
+ "status": "default"
+ },
+ "495": {
+ "status": "not_a_starter"
+ },
+ "490": {
+ "status": "default"
+ },
+ "504": {
+ "status": "not_a_starter"
+ },
+ "506": {
+ "status": "default"
+ },
+ "272": {
+ "status": "injured",
+ "weeks_out": 29
+ },
+ "502": {
+ "status": "default"
+ },
+ "520": {
+ "status": "not_a_starter"
+ },
+ "592": {
+ "status": "not_a_starter"
+ },
+ "598": {
+ "status": "not_a_starter"
+ },
+ "539": {
+ "status": "not_a_starter"
+ },
+ "615": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "179": {
+ "status": "not_a_starter"
+ },
+ "218": {
+ "status": "not_a_starter"
+ },
+ "34": {
+ "status": "not_a_starter"
+ },
+ "3": {
+ "status": "not_a_starter"
+ },
+ "4": {
+ "status": "not_a_starter"
+ },
+ "189": {
+ "status": "not_a_starter"
+ },
+ "394": {
+ "status": "not_a_starter"
+ },
+ "562": {
+ "status": "not_a_starter"
+ },
+ "23": {
+ "status": "not_a_starter"
+ },
+ "88": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "639": {
+ "status": "not_a_starter"
+ },
+ "136": {
+ "status": "default"
+ },
+ "120": {
+ "status": "default"
+ },
+ "316": {
+ "status": "default"
+ },
+ "403": {
+ "status": "injured",
+ "weeks_out": 36
+ },
+ "38": {
+ "status": "default"
+ },
+ "54": {
+ "status": "default"
+ },
+ "514": {
+ "status": "not_a_starter"
+ },
+ "58": {
+ "status": "injured",
+ "weeks_out": 35
+ },
+ "90": {
+ "status": "default"
+ },
+ "425": {
+ "status": "not_a_starter"
+ },
+ "370": {
+ "status": "injured",
+ "weeks_out": 28
+ },
+ "524": {
+ "status": "not_a_starter"
+ },
+ "503": {
+ "status": "not_a_starter"
+ },
+ "196": {
+ "status": "not_a_starter"
+ },
+ "460": {
+ "status": "not_a_starter"
+ },
+ "118": {
+ "status": "not_a_starter"
+ },
+ "428": {
+ "status": "not_a_starter"
+ },
+ "30": {
+ "status": "injured",
+ "weeks_out": 21
+ },
+ "91": {
+ "status": "not_a_starter"
+ },
+ "616": {
+ "status": "not_a_starter"
+ },
+ "112": {
+ "status": "not_a_starter"
+ },
+ "110": {
+ "status": "default"
+ },
+ "327": {
+ "status": "not_a_starter"
+ },
+ "43": {
+ "status": "not_a_starter"
+ },
+ "57": {
+ "status": "not_a_starter"
+ },
+ "574": {
+ "status": "injured",
+ "weeks_out": 30
+ },
+ "570": {
+ "status": "injured",
+ "weeks_out": 26
+ },
+ "571": {
+ "status": "injured",
+ "weeks_out": 33
+ },
+ "9": {
+ "status": "not_a_starter"
+ },
+ "86": {
+ "status": "injured",
+ "weeks_out": 23
+ },
+ "161": {
+ "status": "not_a_starter"
+ },
+ "63": {
+ "status": "not_a_starter"
+ },
+ "154": {
+ "status": "not_a_starter"
+ },
+ "157": {
+ "status": "default"
+ },
+ "472": {
+ "status": "not_a_starter"
+ },
+ "484": {
+ "status": "not_a_starter"
+ },
+ "6": {
+ "status": "default"
+ },
+ "45": {
+ "status": "not_a_starter"
+ },
+ "56": {
+ "status": "not_a_starter"
+ },
+ "721": {
+ "status": "default"
+ },
+ "694": {
+ "status": "injured",
+ "weeks_out": 30
+ },
+ "730": {
+ "status": "injured",
+ "weeks_out": 30
+ },
+ "96": {
+ "status": "not_a_starter"
+ },
+ "93": {
+ "status": "not_a_starter"
+ },
+ "79": {
+ "status": "not_a_starter"
+ },
+ "150": {
+ "status": "not_a_starter"
+ },
+ "165": {
+ "status": "not_a_starter"
+ },
+ "166": {
+ "status": "injured",
+ "weeks_out": 28
+ },
+ "171": {
+ "status": "not_a_starter"
+ },
+ "168": {
+ "status": "default"
+ },
+ "184": {
+ "status": "not_a_starter"
+ },
+ "204": {
+ "status": "not_a_starter"
+ },
+ "211": {
+ "status": "not_a_starter"
+ },
+ "640": {
+ "status": "not_a_starter"
+ },
+ "234": {
+ "status": "not_a_starter"
+ },
+ "239": {
+ "status": "injured",
+ "weeks_out": 30
+ },
+ "305": {
+ "status": "not_a_starter"
+ },
+ "349": {
+ "status": "not_a_starter"
+ },
+ "357": {
+ "status": "not_a_starter"
+ },
+ "355": {
+ "status": "not_a_starter"
+ },
+ "363": {
+ "status": "not_a_starter"
+ },
+ "622": {
+ "status": "not_a_starter"
+ },
+ "607": {
+ "status": "not_a_starter"
+ },
+ "617": {
+ "status": "not_a_starter"
+ },
+ "308": {
+ "status": "not_a_starter"
+ },
+ "312": {
+ "status": "not_a_starter"
+ },
+ "704": {
+ "status": "not_a_starter"
+ },
+ "512": {
+ "status": "not_a_starter"
+ },
+ "523": {
+ "status": "not_a_starter"
+ },
+ "509": {
+ "status": "not_a_starter"
+ },
+ "655": {
+ "status": "not_a_starter"
+ },
+ "656": {
+ "status": "not_a_starter"
+ },
+ "578": {
+ "status": "not_a_starter"
+ },
+ "65": {
+ "status": "not_a_starter"
+ },
+ "333": {
+ "status": "not_a_starter"
+ },
+ "399": {
+ "status": "not_a_starter"
+ },
+ "332": {
+ "status": "injured",
+ "weeks_out": 28
+ },
+ "404": {
+ "status": "not_a_starter"
+ },
+ "465": {
+ "status": "not_a_starter"
+ },
+ "555": {
+ "status": "not_a_starter"
+ },
+ "604": {
+ "status": "not_a_starter"
+ },
+ "537": {
+ "status": "not_a_starter"
+ },
+ "545": {
+ "status": "not_a_starter"
+ },
+ "361": {
+ "status": "not_a_starter"
+ },
+ "285": {
+ "status": "not_a_starter"
+ },
+ "445": {
+ "status": "not_a_starter"
+ },
+ "542": {
+ "status": "not_a_starter"
+ },
+ "420": {
+ "status": "not_a_starter"
+ },
+ "729": {
+ "status": "not_a_starter"
+ },
+ "564": {
+ "status": "not_a_starter"
+ },
+ "267": {
+ "status": "default"
+ },
+ "262": {
+ "status": "default"
+ },
+ "265": {
+ "status": "not_a_starter"
+ },
+ "290": {
+ "status": "injured",
+ "weeks_out": 21
+ },
+ "417": {
+ "status": "default"
+ },
+ "432": {
+ "status": "not_a_starter"
+ },
+ "556": {
+ "status": "not_a_starter"
+ },
+ "559": {
+ "status": "not_a_starter"
+ },
+ "250": {
+ "status": "default"
+ },
+ "365": {
+ "status": "default"
+ },
+ "362": {
+ "status": "default"
+ },
+ "450": {
+ "status": "default"
+ },
+ "135": {
+ "status": "default"
+ },
+ "507": {
+ "status": "injured",
+ "weeks_out": 17
+ },
+ "518": {
+ "status": "not_a_starter"
+ },
+ "654": {
+ "status": "default"
+ },
+ "278": {
+ "status": "not_a_starter"
+ },
+ "122": {
+ "status": "not_a_starter"
+ },
+ "557": {
+ "status": "not_a_starter"
+ },
+ "274": {
+ "status": "not_a_starter"
+ },
+ "457": {
+ "status": "default"
+ },
+ "18": {
+ "status": "default"
+ },
+ "661": {
+ "status": "default"
+ },
+ "541": {
+ "status": "injured",
+ "weeks_out": 30
+ },
+ "610": {
+ "status": "default"
+ },
+ "322": {
+ "status": "default"
+ },
+ "366": {
+ "status": "default"
+ },
+ "477": {
+ "status": "injured",
+ "weeks_out": 28
+ },
+ "140": {
+ "status": "not_a_starter"
+ },
+ "134": {
+ "status": "not_a_starter"
+ },
+ "141": {
+ "status": "not_a_starter"
+ },
+ "142": {
+ "status": "not_a_starter"
+ },
+ "186": {
+ "status": "not_a_starter"
+ },
+ "194": {
+ "status": "not_a_starter"
+ },
+ "315": {
+ "status": "not_a_starter"
+ },
+ "340": {
+ "status": "not_a_starter"
+ },
+ "339": {
+ "status": "not_a_starter"
+ },
+ "360": {
+ "status": "not_a_starter"
+ },
+ "359": {
+ "status": "not_a_starter"
+ },
+ "364": {
+ "status": "not_a_starter"
+ },
+ "368": {
+ "status": "not_a_starter"
+ },
+ "369": {
+ "status": "not_a_starter"
+ },
+ "379": {
+ "status": "not_a_starter"
+ },
+ "433": {
+ "status": "not_a_starter"
+ },
+ "435": {
+ "status": "not_a_starter"
+ },
+ "533": {
+ "status": "not_a_starter"
+ },
+ "534": {
+ "status": "not_a_starter"
+ },
+ "535": {
+ "status": "injured",
+ "weeks_out": 31
+ },
+ "46": {
+ "status": "not_a_starter"
+ },
+ "92": {
+ "status": "not_a_starter"
+ },
+ "95": {
+ "status": "not_a_starter"
+ },
+ "115": {
+ "status": "not_a_starter"
+ },
+ "117": {
+ "status": "not_a_starter"
+ },
+ "222": {
+ "status": "not_a_starter"
+ },
+ "80": {
+ "status": "not_a_starter"
+ },
+ "22": {
+ "status": "injured",
+ "weeks_out": 36
+ },
+ "289": {
+ "status": "not_a_starter"
+ },
+ "395": {
+ "status": "not_a_starter"
+ },
+ "297": {
+ "status": "not_a_starter"
+ },
+ "51": {
+ "status": "not_a_starter"
+ },
+ "188": {
+ "status": "not_a_starter"
+ },
+ "641": {
+ "status": "not_a_starter"
+ },
+ "177": {
+ "status": "not_a_starter"
+ },
+ "576": {
+ "status": "not_a_starter"
+ },
+ "548": {
+ "status": "not_a_starter"
+ },
+ "89": {
+ "status": "not_a_starter"
+ },
+ "473": {
+ "status": "default"
+ },
+ "599": {
+ "status": "not_a_starter"
+ },
+ "528": {
+ "status": "not_a_starter"
+ },
+ "530": {
+ "status": "not_a_starter"
+ },
+ "692": {
+ "status": "not_a_starter"
+ },
+ "698": {
+ "status": "injured",
+ "weeks_out": 31
+ },
+ "212": {
+ "status": "not_a_starter"
+ },
+ "213": {
+ "status": "not_a_starter"
+ },
+ "214": {
+ "status": "not_a_starter"
+ },
+ "540": {
+ "status": "not_a_starter"
+ },
+ "657": {
+ "status": "not_a_starter"
+ },
+ "176": {
+ "status": "not_a_starter"
+ },
+ "17": {
+ "status": "injured",
+ "weeks_out": 25
+ },
+ "183": {
+ "status": "not_a_starter"
+ },
+ "201": {
+ "status": "not_a_starter"
+ },
+ "197": {
+ "status": "not_a_starter"
+ },
+ "248": {
+ "status": "not_a_starter"
+ },
+ "421": {
+ "status": "injured",
+ "weeks_out": 18
+ },
+ "681": {
+ "status": "default"
+ },
+ "338": {
+ "status": "injured",
+ "weeks_out": 25
+ },
+ "5": {
+ "status": "default"
+ },
+ "235": {
+ "status": "default"
+ },
+ "238": {
+ "status": "injured",
+ "weeks_out": 31
+ },
+ "478": {
+ "status": "injured",
+ "weeks_out": 19
+ },
+ "232": {
+ "status": "injured",
+ "weeks_out": 27
+ },
+ "482": {
+ "status": "not_a_starter"
+ },
+ "483": {
+ "status": "not_a_starter"
+ },
+ "40": {
+ "status": "injured",
+ "weeks_out": 22
+ },
+ "123": {
+ "status": "not_a_starter"
+ },
+ "393": {
+ "status": "not_a_starter"
+ },
+ "496": {
+ "status": "not_a_starter"
+ },
+ "554": {
+ "status": "not_a_starter"
+ },
+ "391": {
+ "status": "injured",
+ "weeks_out": 38
+ },
+ "436": {
+ "status": "injured",
+ "weeks_out": 34
+ },
+ "437": {
+ "status": "injured",
+ "weeks_out": 33
+ },
+ "662": {
+ "status": "injured",
+ "weeks_out": 22
+ },
+ "522": {
+ "status": "injured",
+ "weeks_out": 22
+ },
+ "475": {
+ "status": "injured",
+ "weeks_out": 18
+ },
+ "328": {
+ "status": "injured",
+ "weeks_out": 19
+ },
+ "41": {
+ "status": "default"
+ },
+ "42": {
+ "status": "not_a_starter"
+ },
+ "11": {
+ "status": "injured",
+ "weeks_out": 22
+ },
+ "700": {
+ "status": "injured",
+ "weeks_out": 21
+ },
+ "55": {
+ "status": "injured",
+ "weeks_out": 24
+ },
+ "85": {
+ "status": "injured",
+ "weeks_out": 26
+ },
+ "87": {
+ "status": "default"
+ },
+ "418": {
+ "status": "injured",
+ "weeks_out": 26
+ },
+ "476": {
+ "status": "default"
+ },
+ "469": {
+ "status": "default"
+ },
+ "424": {
+ "status": "injured",
+ "weeks_out": 25
+ },
+ "499": {
+ "status": "injured",
+ "weeks_out": 31
+ },
+ "498": {
+ "status": "not_a_starter"
+ },
+ "1": {
+ "status": "default"
+ },
+ "493": {
+ "status": "injured",
+ "weeks_out": 21
+ },
+ "271": {
+ "status": "injured",
+ "weeks_out": 26
+ },
+ "348": {
+ "status": "default"
+ },
+ "344": {
+ "status": "injured",
+ "weeks_out": 25
+ },
+ "205": {
+ "status": "not_a_starter"
+ },
+ "485": {
+ "status": "default"
+ },
+ "284": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "525": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "696": {
+ "status": "not_a_starter"
+ },
+ "492": {
+ "status": "not_a_starter"
+ },
+ "625": {
+ "status": "not_a_starter"
+ },
+ "261": {
+ "status": "default"
+ },
+ "353": {
+ "status": "injured",
+ "weeks_out": 22
+ },
+ "408": {
+ "status": "injured",
+ "weeks_out": 23
+ },
+ "81": {
+ "status": "injured",
+ "weeks_out": 34
+ },
+ "582": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "587": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "588": {
+ "status": "injured",
+ "weeks_out": 37
+ },
+ "626": {
+ "status": "not_a_starter"
+ },
+ "269": {
+ "status": "not_a_starter"
+ },
+ "638": {
+ "status": "not_a_starter"
+ },
+ "474": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "415": {
+ "status": "injured",
+ "weeks_out": 29
+ },
+ "375": {
+ "status": "injured",
+ "weeks_out": 36
+ },
+ "377": {
+ "status": "not_a_starter"
+ },
+ "597": {
+ "status": "injured",
+ "weeks_out": 29
+ },
+ "648": {
+ "status": "not_a_starter"
+ },
+ "601": {
+ "status": "not_a_starter"
+ },
+ "342": {
+ "status": "default"
+ },
+ "25": {
+ "status": "not_a_starter"
+ },
+ "48": {
+ "status": "default"
+ },
+ "668": {
+ "status": "default"
+ },
+ "276": {
+ "status": "injured",
+ "weeks_out": 25
+ },
+ "716": {
+ "status": "injured",
+ "weeks_out": 32
+ },
+ "568": {
+ "status": "injured",
+ "weeks_out": 27
+ },
+ "735": {
+ "status": "injured",
+ "weeks_out": 26
+ },
+ "637": {
+ "status": "injured",
+ "weeks_out": 26
+ },
+ "785": {
+ "status": "injured",
+ "weeks_out": 29
+ },
+ "727": {
+ "status": "injured",
+ "weeks_out": 28
+ }
+}
\ No newline at end of file
diff --git a/user_xmins_overrides.json b/user_xmins_overrides.json
new file mode 100644
index 0000000000000000000000000000000000000000..53b9cf094ccc36b2d089c5b1553c89baeaf8356c
--- /dev/null
+++ b/user_xmins_overrides.json
@@ -0,0 +1,66 @@
+{
+ "596": {
+ "1": 51,
+ "2": 73,
+ "3": 85
+ },
+ "1": {
+ "1": 88
+ },
+ "33": {
+ "1": 87
+ },
+ "32": {
+ "1": 0
+ },
+ "47": {
+ "1": 50,
+ "2": 86
+ },
+ "49": {
+ "1": 52,
+ "2": 40
+ },
+ "81": {
+ "1": 55
+ },
+ "120": {
+ "1": 64
+ },
+ "316": {
+ "1": 58,
+ "2": 70
+ },
+ "343": {
+ "1": 81
+ },
+ "371": {
+ "1": 68
+ },
+ "421": {
+ "1": 66,
+ "2": 72
+ },
+ "507": {
+ "1": 65
+ },
+ "597": {
+ "1": 76,
+ "2": 62
+ },
+ "23": {
+ "1": 13
+ },
+ "34": {
+ "1": 0
+ },
+ "661": {
+ "16": 77
+ },
+ "107": {
+ "18": 86,
+ "19": 84,
+ "20": 84,
+ "21": 83
+ }
+}
\ No newline at end of file
+ 
+