Spaces:
Running
Running
| # Fantasy Baseball Optimizer • Final Working Version | |
| # ------------------------------------------------- | |
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| import pulp | |
| import os | |
| import tempfile | |
| import logging | |
| import traceback | |
| # ---------- Logging ---------- | |
| logging.basicConfig( | |
| level=logging.INFO, | |
| format="%(asctime)s %(levelname)-8s %(message)s", | |
| datefmt="%H:%M:%S" | |
| ) | |
| log = logging.getLogger(__name__) | |
| # ---------- Helpers ---------- | |
| def cache_file(obj, label): | |
| if isinstance(obj, str): return obj | |
| d = os.path.join(tempfile.gettempdir(), "fb_cache") | |
| os.makedirs(d, exist_ok=True) | |
| p = os.path.join(d, label) | |
| with open(obj.name, 'rb') as s, open(p, 'wb') as t: | |
| t.write(s.read()) | |
| return p | |
| def swap_name(n): | |
| if pd.isna(n) or ',' not in str(n): return str(n).strip() | |
| last, first = [x.strip() for x in n.split(',', 1)] | |
| return f"{first} {last}" | |
| def parse_4(txt): | |
| if pd.isna(txt): return ["","","",""] | |
| parts = txt.split()[:4] | |
| outs = [] | |
| for w in parts: | |
| if '(' in w and ')' in w: | |
| outs.append(w.split('(')[-1][0].upper()) | |
| else: outs.append('') | |
| return outs + ['']*(4-len(outs)) | |
| def enforce_util_only(df): | |
| df = df.copy() | |
| mask = df['Players'].str.contains('Ohtani', case=False, na=False) | |
| df.loc[mask, 'Pos'] = 'UTIL' | |
| return df | |
| def gradient(v, high_good=True): | |
| if not isinstance(v, (int, float)): return '' | |
| pct = max(0, min(v/5 if high_good else (5-v)/5, 1)) | |
| r, g = int(255*(1-pct)), int(255*pct) | |
| return f"background-color:rgba({r},{g},0,0.4)" | |
| def color_handed(v): | |
| if v=='L': return 'background-color:#3b6ff7;color:#fff' | |
| if v=='R': return 'background-color:#d93025;color:#fff' | |
| return '' | |
| # ---------- Standings ---------- | |
| def compute_boosts(std, team): | |
| cats = ['R','HR','RBI','SB','AVG','K','W','SV','ERA','WHIP'] | |
| std['Team'] = std['Team'].astype(str).str.lower().str.strip() | |
| if team.lower() not in std['Team'].values: | |
| raise ValueError(f"Team {team} not in standings") | |
| row = std.loc[std['Team']==team.lower()].iloc[0] | |
| raw_r, boosts = {}, {} | |
| rank_strs = [] | |
| for c in cats: | |
| col = pd.to_numeric(std[c], errors='coerce') | |
| val = pd.to_numeric(row[c], errors='coerce') | |
| higher = c not in ['ERA','WHIP'] | |
| rk = 1 + (col>val).sum() if higher else 1 + (col<val).sum() | |
| raw_r[c] = rk | |
| suf = "tsnrhtdd"[((rk//10)%10!=1)*(rk%10<4)*(rk%10)::4] | |
| rank_strs.append(f"{rk}{suf}") | |
| base = (rk-1)/(len(col)-1) if len(col)>1 else 0 | |
| mult = 10 if c in cats[:5] else 5 | |
| boosts[c] = round(mult * base, 1) | |
| df = pd.DataFrame([rank_strs, [boosts[c] for c in cats]], | |
| index=['Rank','Boost'], columns=cats) | |
| return df, pd.Series(raw_r) | |
| def style_standings(df, raw): | |
| sty = df.style.hide(axis='index').set_table_styles([ | |
| {'selector':'th','props':[('text-align','center')]}, | |
| {'selector':'td','props':[('text-align','center')]}]) | |
| max_r = raw.max() | |
| for c in df.columns: | |
| rk = raw[c] | |
| pct = (rk-1)/(max_r-1) if max_r>1 else 0 | |
| r, g = int(255*pct), int(255*(1-pct)) | |
| sty = sty.set_properties(subset=pd.IndexSlice['Rank',c], | |
| **{'background-color':f'rgba({r},{g},0,0.4)'}) | |
| return sty.format(precision=1, subset=pd.IndexSlice['Boost',:]).to_html() | |
| # ---------- Scoring ---------- | |
| def add_scores(hit, pit, hpj, ppj, boost_df, mult, scale): | |
| hstats=['R','HR','RBI','SB','AVG'] | |
| pstats=['K','W','SV','ERA','WHIP'] | |
| for df, stats in [(hit,hstats),(hpj,hstats)]: | |
| for c in stats: | |
| df[c] = pd.to_numeric(df[c], errors='coerce').fillna(0) | |
| for df, stats in [(pit,pstats),(ppj,pstats)]: | |
| for c in stats: | |
| df[c] = pd.to_numeric(df[c], errors='coerce').fillna(0) | |
| hmu, hsd = hpj[hstats].mean(), hpj[hstats].std().replace(0,1) | |
| pmu, psd = ppj[pstats].mean(), ppj[pstats].std().replace(0,1) | |
| for s in hstats: | |
| hit[f'Z_{s}'] = (hit[s]-hmu[s])/(hsd[s]/scale) | |
| for s in pstats: | |
| diff = (pmu[s]-pit[s]) if s in ['ERA','WHIP'] else (pit[s]-pmu[s]) | |
| pit[f'Z_{s}'] = diff/(psd[s]/scale) | |
| hw = boost_df.loc['Boost',hstats].values*10 | |
| pw = boost_df.loc['Boost',pstats].values*5 | |
| hit['Boost'] = hit[[f'Z_{s}' for s in hstats]].dot(hw)/hw.sum() | |
| pit['Boost'] = pit[[f'Z_{s}' for s in pstats]].dot(pw)/pw.sum() | |
| hit['MASH'] = hit['$'].fillna(0) + hit['Boost']*mult | |
| pit['MASH'] = pit['$'].fillna(0) + pit['Boost']*mult | |
| return hit, pit | |
| # ---------- Optimization ---------- | |
| def optimize_lineup(df): | |
| slots=['C1','C2','1B','2B','3B','SS']+[f'OF{i}' for i in range(1,6)]+['CI','MI','UTIL'] | |
| elig={} | |
| for i,r in df.iterrows(): | |
| p=set(str(r['Pos']).split(',')) | |
| v={'UTIL'} | |
| if 'C' in p: v|={'C1','C2'} | |
| if '1B' in p: v|={'1B','CI'} | |
| if '2B' in p: v|={'2B','MI'} | |
| if '3B' in p: v|={'3B','CI'} | |
| if 'SS' in p: v|={'SS','MI'} | |
| if 'OF' in p or any(pp.startswith('OF') for pp in p): v|={f'OF{i}' for i in range(1,6)} | |
| elig[i]=v | |
| for s in slots: | |
| if not any(s in v for v in elig.values()): | |
| idx=len(df) | |
| df.loc[idx,['Players','Pos','$','Boost','MASH']]=[f'No {s}',s,0,0,-0.001] | |
| elig[idx]={s} | |
| prob=pulp.LpProblem('L',pulp.LpMaximize) | |
| x={(i,s):pulp.LpVariable(f'x_{i}_{s}',cat='Binary') for i in elig for s in elig[i]} | |
| for s in slots: | |
| prob += pulp.lpSum(x[i,s] for i in elig if s in elig[i]) == 1 | |
| for i in elig: | |
| prob += pulp.lpSum(x[i,s] for s in elig[i]) <= 1 | |
| prob += pulp.lpSum(df.loc[i,'MASH']*x[i,s] for i,s in x) | |
| prob.solve(pulp.PULP_CBC_CMD(msg=False)) | |
| df['Slot']=pd.Series({i:s for(i,s),v in x.items() if v.value()==1}) | |
| slot2pos={**{f'OF{i}':'OF' for i in range(1,6)},'C1':'C','C2':'C','1B':'1B', | |
| '2B':'2B','3B':'3B','SS':'SS','CI':'CI','MI':'MI','UTIL':'UTIL'} | |
| df['Pos']=df['Slot'].map(slot2pos).fillna('Bench') | |
| return df | |
| # ---------- Main Process ---------- | |
| def run(roster,hproj,pproj,std,team,boost_x,scale): | |
| try: | |
| rost=pd.read_csv(cache_file(roster,'r.csv')) | |
| rost['Players']=rost['Players'].apply(swap_name) | |
| hpj=pd.read_csv(cache_file(hproj,'h.csv')) | |
| ppj=pd.read_csv(cache_file(pproj,'p.csv')) | |
| std=pd.read_csv(cache_file(std,'s.csv')) | |
| hpj[['SP1','SP2','SP3','SP4']]=hpj['SP'].apply(parse_4).tolist() | |
| hpj['PA']=pd.to_numeric(hpj['PA'], errors='coerce').fillna(0) | |
| rost['Owner']=rost['Owner'].fillna('').str.lower().str.strip() | |
| rows=rost[rost['Owner']==team.lower()].copy() | |
| rows['isP']=rows['Pos'].str.contains('P',na=False) | |
| hitters=rows[~rows['isP']].merge(hpj,left_on='id',right_on='NFBCID', | |
| how='left',suffixes=('','_proj'),indicator=True) | |
| hitters['has_proj']=hitters['_merge']=='both' | |
| hitters.drop(columns=['_merge'],inplace=True) | |
| pitchers=rows[rows['isP']].merge(ppj,left_on='id',right_on='NFBCID', | |
| how='left',suffixes=('','_proj'),indicator=True) | |
| pitchers['has_proj']=pitchers['_merge']=='both' | |
| pitchers.drop(columns=['_merge'],inplace=True) | |
| for st in ['IP','ERA','WHIP']: | |
| pr=f'{st}_proj' | |
| if pr in pitchers: pitchers[st]=pitchers[pr] | |
| hitters=enforce_util_only(hitters) | |
| boost_df,raw=compute_boosts(std,team) | |
| hitters,pitchers=add_scores(hitters,pitchers,hpj,ppj,boost_df,boost_x,scale) | |
| hitters=optimize_lineup(hitters) | |
| # Get lineup and bench | |
| lineup_players = hitters[hitters['Pos'] != 'Bench'].index | |
| line = hitters.loc[lineup_players].copy() | |
| slot_order=['C1','C2','1B','2B','SS','3B']+[f'OF{i}' for i in range(1,6)]+['CI','MI','UTIL'] | |
| line['Slot'] = pd.Categorical(line['Slot'], categories=slot_order, ordered=True) | |
| line = line.sort_values('Slot') | |
| # ---------- Reassign OF1–OF5 by descending MASH ---------- | |
| of_mask = line['Slot'].isin([f'OF{i}' for i in range(1,6)]) | |
| ofs = line[of_mask].sort_values('MASH', ascending=False).copy() | |
| other = line[~of_mask].copy() | |
| # Reassign best OFs to OF1–OF5 | |
| ofs['Slot'] = [f'OF{i+1}' for i in range(len(ofs))] | |
| line = pd.concat([ofs, other], ignore_index=True) | |
| # Re-sort to maintain the original order | |
| line['Slot'] = pd.Categorical(line['Slot'], categories=slot_order, ordered=True) | |
| line = line.sort_values('Slot') | |
| bench = hitters[ | |
| (hitters['has_proj']) & | |
| (~hitters.index.isin(lineup_players)) | |
| ].sort_values('MASH', ascending=False) | |
| minors=pd.concat([ | |
| hitters[~hitters['has_proj']][['Players','Pos']], | |
| pitchers[~pitchers['has_proj']][['Players','Pos']] | |
| ], ignore_index=True) | |
| # Process pitchers | |
| pproj = pitchers[pitchers['has_proj']] | |
| top9 = pproj.sort_values('MASH', ascending=False).head(9) | |
| bp = pproj.sort_values('MASH', ascending=False).iloc[9:] | |
| # Style columns | |
| lc=['Slot','Players','Pos','MASH','$','PA','SP1','SP2','SP3','SP4','Boost'] | |
| bc=['Players','Pos','MASH','$','PA','SP1','SP2','SP3','SP4','Boost'] | |
| pc=['Players','Pos','MASH','$','IP','ERA','WHIP','Boost'] | |
| def style_df(df, grads=None): | |
| df=df.copy() | |
| if df.empty: return df.to_html(index=False) | |
| df['Boost']=df['Boost'].round(1) | |
| sty=df.style.hide(axis='index').set_table_styles([ | |
| {'selector':'th','props':[('text-align','center')]}, | |
| {'selector':'td','props':[('text-align','center')]}]) | |
| nums=df.select_dtypes(include=[np.number]).columns | |
| if grads: | |
| for c in grads: | |
| high_good = False if c in ['ERA','WHIP'] else True | |
| sty=sty.map(lambda v,hg=high_good: gradient(v,hg), subset=[c]) | |
| for sp in ['SP1','SP2','SP3','SP4']: | |
| if sp in df.columns: sty=sty.map(color_handed, subset=[sp]) | |
| return sty.format('{:.2f}', subset=nums).to_html() | |
| return ( | |
| style_standings(boost_df,raw), | |
| style_df(line[lc], grads=['MASH','$']), | |
| style_df(bench[bc], grads=['MASH','$']), | |
| style_df(top9[pc], grads=['MASH','$']), | |
| style_df(bp[pc], grads=['MASH','$']), | |
| minors.to_html(index=False) | |
| ) | |
| except Exception as e: | |
| log.error(e) | |
| log.debug(traceback.format_exc()) | |
| err=f"<pre>{e}</pre>" | |
| return err,err,err,err,err,err | |
| # ---------- UI Setup ---------- | |
| with gr.Blocks() as demo: | |
| gr.Markdown("# 🏆 Fantasy Baseball Optimizer v4.10") | |
| with gr.Row(): | |
| with gr.Column(): | |
| r_in=gr.File(label="Roster CSV") | |
| h_in=gr.File(label="Hitters CSV") | |
| p_in=gr.File(label="Pitchers CSV") | |
| s_in=gr.File(label="Standings CSV") | |
| t_in=gr.Textbox(label="Team Name") | |
| b_in=gr.Slider(0.5,10.0,value=3.0,step=0.5,label="Boost ×") | |
| sc_in=gr.Slider(0.1,2.0,value=1.0,step=0.1,label="StdDev Scale") | |
| btn=gr.Button("Optimize 🚀") | |
| with gr.Column(): | |
| std_html=gr.HTML(label="Standings + Boost") | |
| line_html=gr.HTML(label="Lineup") | |
| bench_html=gr.HTML(label="Bench Hitters") | |
| tp_html=gr.HTML(label="Top 9 Pitchers") | |
| bp_html=gr.HTML(label="Bullpen & Reserves") | |
| min_html=gr.HTML(label="In the Minors") | |
| btn.click( | |
| run, | |
| inputs=[r_in,h_in,p_in,s_in,t_in,b_in,sc_in], | |
| outputs=[std_html,line_html,bench_html,tp_html,bp_html,min_html] | |
| ) | |
| if __name__=="__main__": | |
| demo.launch(server_name="0.0.0.0", server_port=7860) |