diff --git a/app/routers_v3/pitchingstats.py b/app/routers_v3/pitchingstats.py index 54364ec..4625f80 100644 --- a/app/routers_v3/pitchingstats.py +++ b/app/routers_v3/pitchingstats.py @@ -1,20 +1,29 @@ -import datetime -import os - from fastapi import APIRouter, Depends, HTTPException, Query from typing import List, Optional, Literal import logging import pydantic -from ..db_engine import db, PitchingStat, Team, Player, Current, model_to_dict, chunked, fn, per_season_weeks -from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA, handle_db_errors - -logger = logging.getLogger('discord_app') - -router = APIRouter( - prefix='/api/v3/pitchingstats', - tags=['pitchingstats'] +from ..db_engine import ( + db, + PitchingStat, + Team, + Player, + Current, + model_to_dict, + chunked, + fn, + per_season_weeks, ) +from ..dependencies import ( + oauth2_scheme, + valid_token, + PRIVATE_IN_SCHEMA, + handle_db_errors, +) + +logger = logging.getLogger("discord_app") + +router = APIRouter(prefix="/api/v3/pitchingstats", tags=["pitchingstats"]) class PitStatModel(pydantic.BaseModel): @@ -48,29 +57,37 @@ class PitStatList(pydantic.BaseModel): stats: List[PitStatModel] -@router.get('') +@router.get("") @handle_db_errors async def get_pitstats( - season: int, s_type: Optional[str] = 'regular', team_abbrev: list = Query(default=None), - player_name: list = Query(default=None), player_id: list = Query(default=None), - week_start: Optional[int] = None, week_end: Optional[int] = None, game_num: list = Query(default=None), - limit: Optional[int] = None, ip_min: Optional[float] = None, sort: Optional[str] = None, - short_output: Optional[bool] = True): - if 'post' in s_type.lower(): + season: int, + s_type: Optional[str] = "regular", + team_abbrev: list = Query(default=None), + player_name: list = Query(default=None), + player_id: list = Query(default=None), + week_start: Optional[int] = None, + week_end: Optional[int] = None, + game_num: list = Query(default=None), + limit: Optional[int] = None, + ip_min: Optional[float] = None, + sort: Optional[str] = None, + short_output: Optional[bool] = True, +): + if "post" in s_type.lower(): all_stats = PitchingStat.post_season(season) if all_stats.count() == 0: db.close() - return {'count': 0, 'stats': []} - elif s_type.lower() in ['combined', 'total', 'all']: + return {"count": 0, "stats": []} + elif s_type.lower() in ["combined", "total", "all"]: all_stats = PitchingStat.combined_season(season) if all_stats.count() == 0: db.close() - return {'count': 0, 'stats': []} + return {"count": 0, "stats": []} else: all_stats = PitchingStat.regular_season(season) if all_stats.count() == 0: db.close() - return {'count': 0, 'stats': []} + return {"count": 0, "stats": []} if team_abbrev is not None: t_query = Team.select().where(Team.abbrev << [x.upper() for x in team_abbrev]) @@ -79,7 +96,9 @@ async def get_pitstats( if player_id: all_stats = all_stats.where(PitchingStat.player_id << player_id) else: - p_query = Player.select_season(season).where(fn.Lower(Player.name) << [x.lower() for x in player_name]) + p_query = Player.select_season(season).where( + fn.Lower(Player.name) << [x.lower() for x in player_name] + ) all_stats = all_stats.where(PitchingStat.player << p_query) if game_num: all_stats = all_stats.where(PitchingStat.game == game_num) @@ -96,7 +115,7 @@ async def get_pitstats( db.close() raise HTTPException( status_code=404, - detail=f'Start week {start} is after end week {end} - cannot pull stats' + detail=f"Start week {start} is after end week {end} - cannot pull stats", ) all_stats = all_stats.where( (PitchingStat.week >= start) & (PitchingStat.week <= end) @@ -105,58 +124,81 @@ async def get_pitstats( if limit: all_stats = all_stats.limit(limit) if sort: - if sort == 'newest': + if sort == "newest": all_stats = all_stats.order_by(-PitchingStat.week, -PitchingStat.game) return_stats = { - 'count': all_stats.count(), - 'stats': [model_to_dict(x, recurse=not short_output) for x in all_stats] + "count": all_stats.count(), + "stats": [model_to_dict(x, recurse=not short_output) for x in all_stats], } db.close() return return_stats -@router.get('/totals') +@router.get("/totals") @handle_db_errors async def get_totalstats( - season: int, s_type: Literal['regular', 'post', 'total', None] = None, team_abbrev: list = Query(default=None), - team_id: list = Query(default=None), player_name: list = Query(default=None), - week_start: Optional[int] = None, week_end: Optional[int] = None, game_num: list = Query(default=None), - is_sp: Optional[bool] = None, ip_min: Optional[float] = 0.25, sort: Optional[str] = None, - player_id: list = Query(default=None), short_output: Optional[bool] = False, - group_by: Literal['team', 'player', 'playerteam'] = 'player', week: list = Query(default=None)): + season: int, + s_type: Literal["regular", "post", "total", None] = None, + team_abbrev: list = Query(default=None), + team_id: list = Query(default=None), + player_name: list = Query(default=None), + week_start: Optional[int] = None, + week_end: Optional[int] = None, + game_num: list = Query(default=None), + is_sp: Optional[bool] = None, + ip_min: Optional[float] = 0.25, + sort: Optional[str] = None, + player_id: list = Query(default=None), + short_output: Optional[bool] = False, + group_by: Literal["team", "player", "playerteam"] = "player", + week: list = Query(default=None), +): if sum(1 for x in [s_type, (week_start or week_end), week] if x is not None) > 1: - raise HTTPException(status_code=400, detail=f'Only one of s_type, week_start/week_end, or week may be used.') + raise HTTPException( + status_code=400, + detail=f"Only one of s_type, week_start/week_end, or week may be used.", + ) # Build SELECT fields conditionally based on group_by to match GROUP BY exactly select_fields = [] - - if group_by == 'player': + + if group_by == "player": select_fields = [PitchingStat.player] - elif group_by == 'team': + elif group_by == "team": select_fields = [PitchingStat.team] - elif group_by == 'playerteam': + elif group_by == "playerteam": select_fields = [PitchingStat.player, PitchingStat.team] else: # Default case select_fields = [PitchingStat.player] all_stats = ( - PitchingStat - .select(*select_fields, - fn.SUM(PitchingStat.ip).alias('sum_ip'), - fn.SUM(PitchingStat.hit).alias('sum_hit'), fn.SUM(PitchingStat.run).alias('sum_run'), - fn.SUM(PitchingStat.erun).alias('sum_erun'), fn.SUM(PitchingStat.so).alias('sum_so'), - fn.SUM(PitchingStat.bb).alias('sum_bb'), fn.SUM(PitchingStat.hbp).alias('sum_hbp'), - fn.SUM(PitchingStat.wp).alias('sum_wp'), fn.SUM(PitchingStat.balk).alias('sum_balk'), - fn.SUM(PitchingStat.hr).alias('sum_hr'), fn.SUM(PitchingStat.ir).alias('sum_ir'), - fn.SUM(PitchingStat.win).alias('sum_win'), fn.SUM(PitchingStat.loss).alias('sum_loss'), - fn.SUM(PitchingStat.hold).alias('sum_hold'), fn.SUM(PitchingStat.sv).alias('sum_sv'), - fn.SUM(PitchingStat.bsv).alias('sum_bsv'), fn.SUM(PitchingStat.irs).alias('sum_irs'), - fn.SUM(PitchingStat.gs).alias('sum_gs'), fn.COUNT(PitchingStat.game).alias('sum_games')) - .where(PitchingStat.season == season) - .having(fn.SUM(PitchingStat.ip) >= ip_min) + PitchingStat.select( + *select_fields, + fn.SUM(PitchingStat.ip).alias("sum_ip"), + fn.SUM(PitchingStat.hit).alias("sum_hit"), + fn.SUM(PitchingStat.run).alias("sum_run"), + fn.SUM(PitchingStat.erun).alias("sum_erun"), + fn.SUM(PitchingStat.so).alias("sum_so"), + fn.SUM(PitchingStat.bb).alias("sum_bb"), + fn.SUM(PitchingStat.hbp).alias("sum_hbp"), + fn.SUM(PitchingStat.wp).alias("sum_wp"), + fn.SUM(PitchingStat.balk).alias("sum_balk"), + fn.SUM(PitchingStat.hr).alias("sum_hr"), + fn.SUM(PitchingStat.ir).alias("sum_ir"), + fn.SUM(PitchingStat.win).alias("sum_win"), + fn.SUM(PitchingStat.loss).alias("sum_loss"), + fn.SUM(PitchingStat.hold).alias("sum_hold"), + fn.SUM(PitchingStat.sv).alias("sum_sv"), + fn.SUM(PitchingStat.bsv).alias("sum_bsv"), + fn.SUM(PitchingStat.irs).alias("sum_irs"), + fn.SUM(PitchingStat.gs).alias("sum_gs"), + fn.COUNT(PitchingStat.game).alias("sum_games"), + ) + .where(PitchingStat.season == season) + .having(fn.SUM(PitchingStat.ip) >= ip_min) ) if True in [s_type is not None, week_start is not None, week_end is not None]: @@ -166,16 +208,20 @@ async def get_totalstats( elif week_start is not None or week_end is not None: if week_start is None or week_end is None: raise HTTPException( - status_code=400, detail='Both week_start and week_end must be included if either is used.' + status_code=400, + detail="Both week_start and week_end must be included if either is used.", + ) + weeks["start"] = week_start + if week_end < weeks["start"]: + raise HTTPException( + status_code=400, + detail="week_end must be greater than or equal to week_start", ) - weeks['start'] = week_start - if week_end < weeks['start']: - raise HTTPException(status_code=400, detail='week_end must be greater than or equal to week_start') else: - weeks['end'] = week_end + weeks["end"] = week_end all_stats = all_stats.where( - (PitchingStat.week >= weeks['start']) & (PitchingStat.week <= weeks['end']) + (PitchingStat.week >= weeks["start"]) & (PitchingStat.week <= weeks["end"]) ) elif week is not None: @@ -189,9 +235,9 @@ async def get_totalstats( if not is_sp: all_stats = all_stats.where(PitchingStat.gs == 0) if sort is not None: - if sort == 'player': + if sort == "player": all_stats = all_stats.order_by(PitchingStat.player) - elif sort == 'team': + elif sort == "team": all_stats = all_stats.order_by(PitchingStat.team) if group_by is not None: # Use the same fields for GROUP BY as we used for SELECT @@ -200,67 +246,76 @@ async def get_totalstats( all_teams = Team.select().where(Team.id << team_id) all_stats = all_stats.where(PitchingStat.team << all_teams) elif team_abbrev is not None: - all_teams = Team.select().where(fn.Lower(Team.abbrev) << [x.lower() for x in team_abbrev]) + all_teams = Team.select().where( + fn.Lower(Team.abbrev) << [x.lower() for x in team_abbrev] + ) all_stats = all_stats.where(PitchingStat.team << all_teams) if player_name is not None: - all_players = Player.select().where(fn.Lower(Player.name) << [x.lower() for x in player_name]) + all_players = Player.select().where( + fn.Lower(Player.name) << [x.lower() for x in player_name] + ) all_stats = all_stats.where(PitchingStat.player << all_players) elif player_id is not None: all_players = Player.select().where(Player.id << player_id) all_stats = all_stats.where(PitchingStat.player << all_players) - return_stats = { - 'count': all_stats.count(), - 'stats': [] - } - + return_stats = {"count": all_stats.count(), "stats": []} + for x in all_stats: # Handle player field based on grouping with safe access - this_player = 'TOT' - if 'player' in group_by and hasattr(x, 'player'): - this_player = x.player_id if short_output else model_to_dict(x.player, recurse=False) + this_player = "TOT" + if "player" in group_by and hasattr(x, "player"): + this_player = ( + x.player_id if short_output else model_to_dict(x.player, recurse=False) + ) - # Handle team field based on grouping with safe access - this_team = 'TOT' - if 'team' in group_by and hasattr(x, 'team'): - this_team = x.team_id if short_output else model_to_dict(x.team, recurse=False) - - return_stats['stats'].append({ - 'player': this_player, - 'team': this_team, - 'ip': x.sum_ip, - 'hit': x.sum_hit, - 'run': x.sum_run, - 'erun': x.sum_erun, - 'so': x.sum_so, - 'bb': x.sum_bb, - 'hbp': x.sum_hbp, - 'wp': x.sum_wp, - 'balk': x.sum_balk, - 'hr': x.sum_hr, - 'ir': x.sum_ir, - 'irs': x.sum_irs, - 'gs': x.sum_gs, - 'games': x.sum_games, - 'win': x.sum_win, - 'loss': x.sum_loss, - 'hold': x.sum_hold, - 'sv': x.sum_sv, - 'bsv': x.sum_bsv - }) + # Handle team field based on grouping with safe access + this_team = "TOT" + if "team" in group_by and hasattr(x, "team"): + this_team = ( + x.team_id if short_output else model_to_dict(x.team, recurse=False) + ) + + return_stats["stats"].append( + { + "player": this_player, + "team": this_team, + "ip": x.sum_ip, + "hit": x.sum_hit, + "run": x.sum_run, + "erun": x.sum_erun, + "so": x.sum_so, + "bb": x.sum_bb, + "hbp": x.sum_hbp, + "wp": x.sum_wp, + "balk": x.sum_balk, + "hr": x.sum_hr, + "ir": x.sum_ir, + "irs": x.sum_irs, + "gs": x.sum_gs, + "games": x.sum_games, + "win": x.sum_win, + "loss": x.sum_loss, + "hold": x.sum_hold, + "sv": x.sum_sv, + "bsv": x.sum_bsv, + } + ) db.close() return return_stats -@router.patch('/{stat_id}', include_in_schema=PRIVATE_IN_SCHEMA) +@router.patch("/{stat_id}", include_in_schema=PRIVATE_IN_SCHEMA) @handle_db_errors -async def patch_pitstats(stat_id: int, new_stats: PitStatModel, token: str = Depends(oauth2_scheme)): +async def patch_pitstats( + stat_id: int, new_stats: PitStatModel, token: str = Depends(oauth2_scheme) +): if not valid_token(token): - logger.warning(f'patch_pitstats - Bad Token: {token}') - raise HTTPException(status_code=401, detail='Unauthorized') + logger.warning(f"patch_pitstats - Bad Token: {token}") + raise HTTPException(status_code=401, detail="Unauthorized") if PitchingStat.get_or_none(PitchingStat.id == stat_id) is None: - raise HTTPException(status_code=404, detail=f'Stat ID {stat_id} not found') + raise HTTPException(status_code=404, detail=f"Stat ID {stat_id} not found") PitchingStat.update(**new_stats.dict()).where(PitchingStat.id == stat_id).execute() r_stat = model_to_dict(PitchingStat.get_by_id(stat_id)) @@ -268,12 +323,12 @@ async def patch_pitstats(stat_id: int, new_stats: PitStatModel, token: str = Dep return r_stat -@router.post('', include_in_schema=PRIVATE_IN_SCHEMA) +@router.post("", include_in_schema=PRIVATE_IN_SCHEMA) @handle_db_errors async def post_pitstats(s_list: PitStatList, token: str = Depends(oauth2_scheme)): if not valid_token(token): - logger.warning(f'post_pitstats - Bad Token: {token}') - raise HTTPException(status_code=401, detail='Unauthorized') + logger.warning(f"post_pitstats - Bad Token: {token}") + raise HTTPException(status_code=401, detail="Unauthorized") all_stats = [] @@ -281,9 +336,13 @@ async def post_pitstats(s_list: PitStatList, token: str = Depends(oauth2_scheme) team = Team.get_or_none(Team.id == x.team_id) this_player = Player.get_or_none(Player.id == x.player_id) if team is None: - raise HTTPException(status_code=404, detail=f'Team ID {x.team_id} not found') + raise HTTPException( + status_code=404, detail=f"Team ID {x.team_id} not found" + ) if this_player is None: - raise HTTPException(status_code=404, detail=f'Player ID {x.player_id} not found') + raise HTTPException( + status_code=404, detail=f"Player ID {x.player_id} not found" + ) all_stats.append(PitchingStat(**x.dict())) @@ -292,4 +351,4 @@ async def post_pitstats(s_list: PitStatList, token: str = Depends(oauth2_scheme) PitchingStat.insert_many(batch).on_conflict_ignore().execute() db.close() - return f'Added {len(all_stats)} batting lines' + return f"Added {len(all_stats)} batting lines" diff --git a/app/routers_v3/standings.py b/app/routers_v3/standings.py index b59dc26..f5ef37e 100644 --- a/app/routers_v3/standings.py +++ b/app/routers_v3/standings.py @@ -1,24 +1,29 @@ from fastapi import APIRouter, Depends, HTTPException, Query from typing import List, Optional import logging -import pydantic from ..db_engine import db, Standings, Team, Division, model_to_dict, chunked, fn -from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA, handle_db_errors - -logger = logging.getLogger('discord_app') - -router = APIRouter( - prefix='/api/v3/standings', - tags=['standings'] +from ..dependencies import ( + oauth2_scheme, + valid_token, + PRIVATE_IN_SCHEMA, + handle_db_errors, ) +logger = logging.getLogger("discord_app") -@router.get('') +router = APIRouter(prefix="/api/v3/standings", tags=["standings"]) + + +@router.get("") @handle_db_errors async def get_standings( - season: int, team_id: list = Query(default=None), league_abbrev: Optional[str] = None, - division_abbrev: Optional[str] = None, short_output: Optional[bool] = False): + season: int, + team_id: list = Query(default=None), + league_abbrev: Optional[str] = None, + division_abbrev: Optional[str] = None, + short_output: Optional[bool] = False, +): standings = Standings.select_season(season) # if standings.count() == 0: @@ -30,55 +35,66 @@ async def get_standings( standings = standings.where(Standings.team << t_query) if league_abbrev is not None: - l_query = Division.select().where(fn.Lower(Division.league_abbrev) == league_abbrev.lower()) + l_query = Division.select().where( + fn.Lower(Division.league_abbrev) == league_abbrev.lower() + ) standings = standings.where(Standings.team.division << l_query) if division_abbrev is not None: - d_query = Division.select().where(fn.Lower(Division.division_abbrev) == division_abbrev.lower()) + d_query = Division.select().where( + fn.Lower(Division.division_abbrev) == division_abbrev.lower() + ) standings = standings.where(Standings.team.division << d_query) def win_pct(this_team_stan): if this_team_stan.wins + this_team_stan.losses == 0: return 0 else: - return (this_team_stan.wins / (this_team_stan.wins + this_team_stan.losses)) + \ - (this_team_stan.run_diff * .000001) + return ( + this_team_stan.wins / (this_team_stan.wins + this_team_stan.losses) + ) + (this_team_stan.run_diff * 0.000001) div_teams = [x for x in standings] div_teams.sort(key=lambda team: win_pct(team), reverse=True) return_standings = { - 'count': len(div_teams), - 'standings': [model_to_dict(x, recurse=not short_output) for x in div_teams] + "count": len(div_teams), + "standings": [model_to_dict(x, recurse=not short_output) for x in div_teams], } db.close() return return_standings -@router.get('/team/{team_id}') +@router.get("/team/{team_id}") @handle_db_errors async def get_team_standings(team_id: int): this_stan = Standings.get_or_none(Standings.team_id == team_id) if this_stan is None: - raise HTTPException(status_code=404, detail=f'No standings found for team id {team_id}') + raise HTTPException( + status_code=404, detail=f"No standings found for team id {team_id}" + ) return model_to_dict(this_stan) -@router.patch('/{stan_id}', include_in_schema=PRIVATE_IN_SCHEMA) +@router.patch("/{stan_id}", include_in_schema=PRIVATE_IN_SCHEMA) @handle_db_errors async def patch_standings( - stan_id, wins: Optional[int] = None, losses: Optional[int] = None, token: str = Depends(oauth2_scheme)): + stan_id, + wins: Optional[int] = None, + losses: Optional[int] = None, + token: str = Depends(oauth2_scheme), +): if not valid_token(token): - logger.warning(f'patch_standings - Bad Token: {token}') - raise HTTPException(status_code=401, detail='Unauthorized') + logger.warning(f"patch_standings - Bad Token: {token}") + raise HTTPException(status_code=401, detail="Unauthorized") try: this_stan = Standings.get_by_id(stan_id) except Exception as e: db.close() - raise HTTPException(status_code=404, detail=f'No team found with id {stan_id}') + raise HTTPException(status_code=404, detail=f"No team found with id {stan_id}") if wins: this_stan.wins = wins @@ -91,35 +107,35 @@ async def patch_standings( return model_to_dict(this_stan) -@router.post('/s{season}/new', include_in_schema=PRIVATE_IN_SCHEMA) +@router.post("/s{season}/new", include_in_schema=PRIVATE_IN_SCHEMA) @handle_db_errors async def post_standings(season: int, token: str = Depends(oauth2_scheme)): if not valid_token(token): - logger.warning(f'post_standings - Bad Token: {token}') - raise HTTPException(status_code=401, detail='Unauthorized') + logger.warning(f"post_standings - Bad Token: {token}") + raise HTTPException(status_code=401, detail="Unauthorized") new_teams = [] all_teams = Team.select().where(Team.season == season) for x in all_teams: - new_teams.append(Standings({'team_id': x.id})) - + new_teams.append(Standings({"team_id": x.id})) + with db.atomic(): for batch in chunked(new_teams, 16): Standings.insert_many(batch).on_conflict_ignore().execute() db.close() - return f'Inserted {len(new_teams)} standings' + return f"Inserted {len(new_teams)} standings" -@router.post('/s{season}/recalculate', include_in_schema=PRIVATE_IN_SCHEMA) +@router.post("/s{season}/recalculate", include_in_schema=PRIVATE_IN_SCHEMA) @handle_db_errors async def recalculate_standings(season: int, token: str = Depends(oauth2_scheme)): if not valid_token(token): - logger.warning(f'recalculate_standings - Bad Token: {token}') - raise HTTPException(status_code=401, detail='Unauthorized') + logger.warning(f"recalculate_standings - Bad Token: {token}") + raise HTTPException(status_code=401, detail="Unauthorized") code = Standings.recalculate(season) db.close() if code == 69: - raise HTTPException(status_code=500, detail=f'Error recreating Standings rows') - return f'Just recalculated standings for season {season}' + raise HTTPException(status_code=500, detail=f"Error recreating Standings rows") + return f"Just recalculated standings for season {season}"