Add RP lookup

app/routers_v2/teams.py

@@ -1,8 +1,8 @@
 from datetime import datetime
 
 import pandas as pd
-from fastapi import APIRouter, Depends, HTTPException, Response
+from fastapi import APIRouter, Depends, HTTPException, Response, Query
-from typing import Optional
+from typing import Optional, Literal
 import logging
 import pydantic
 from pandas import DataFrame
@@ -341,6 +341,29 @@ async def get_team_lineup(team_id: int, difficulty_name: str, pitcher_name: str,
     }
 
 
+def sort_pitchers(pitching_card_query) -> DataFrame | None:
+    all_s = [model_to_dict(x, recurse=False) for x in pitching_card_query]
+    if len(all_s) == 0:
+        logging.error(f'Empty pitching_card_query: {pitching_card_query}')
+        return None
+
+    pitcher_df = pd.DataFrame(all_s).set_index('player', drop=False)
+    logging.info(f'pitcher_df: {pitcher_df}')
+
+    def get_total_ops(df_data):
+        vlval = PitchingCardRatings.get_or_none(
+            PitchingCardRatings.pitchingcard_id == df_data['id'], PitchingCardRatings.vs_hand == 'L')
+        vrval = PitchingCardRatings.get_or_none(
+            PitchingCardRatings.pitchingcard_id == df_data['id'], PitchingCardRatings.vs_hand == 'R')
+
+        ops_vl = vlval.obp + vlval.slg
+        ops_vr = vrval.obp + vrval.slg
+        return (ops_vr + ops_vl + min(ops_vl, ops_vr)) / 3
+
+    pitcher_df['total_ops'] = pitcher_df.apply(get_total_ops, axis=1)
+    return pitcher_df.sort_values(by='total_ops')
+
+
 @router.get('/{team_id}/sp/{difficulty_name}')
 async def get_team_sp(team_id: int, difficulty_name: str, sp_rank: int):
     logging.info(f'get_team_sp - team_id: {team_id} / difficulty_name: {difficulty_name} / sp_rank: {sp_rank}')
@@ -424,6 +447,113 @@ async def get_team_sp(team_id: int, difficulty_name: str, sp_rank: int):
     raise HTTPException(status_code=500, detail=f'No SP #{sp_rank} found for Team {team_id}')
 
 
+@router.get('/{team_id}/rp/{difficulty_name}')
+async def get_team_rp(
+        team_id: int, difficulty_name: str, need: Literal['length', 'setup', 'closer', 'middle'],
+        used_pitcher_ids: list = Query(default=[])):
+    logging.info(f'get_team_rp - team_id: {team_id} / difficulty_name: {difficulty_name} / need: {need} '
+                 f'/ used_pitcher_ids: {used_pitcher_ids}')
+    this_team = Team.get_or_none(Team.id == team_id)
+    if this_team is None:
+        db.close()
+        raise HTTPException(status_code=404, detail=f'Team id {team_id} not found')
+
+    if difficulty_name not in CARDSETS.keys():
+        db.close()
+        raise HTTPException(status_code=400, detail=f'Difficulty name {difficulty_name} not a valid check')
+
+    all_players = Player.select().where(
+        (Player.mlbclub == this_team.lname) & (Player.player_id.not_in(used_pitcher_ids))
+    )
+
+    legal_players = all_players.where(Player.cardset_id << CARDSETS[difficulty_name]['primary'])
+    if 'secondary' in CARDSETS[difficulty_name]:
+        backup_players = all_players.where(Player.cardset_id << CARDSETS[difficulty_name]['secondary'])
+    else:
+        backup_players = None
+
+    if need == 'closer':
+        for query in [PitchingCard.select().join(Player).where(
+                (PitchingCard.player << legal_players) & (PitchingCard.closer_rating >= 3) &
+                (PitchingCard.starter_rating == 1)),
+            PitchingCard.select().join(Player).where(
+                (PitchingCard.player << legal_players) & (PitchingCard.closer_rating >= 1) &
+                (PitchingCard.starter_rating == 1)),
+            PitchingCard.select().join(Player).where(
+                (PitchingCard.player << backup_players) & (PitchingCard.closer_rating >= 3) &
+                (PitchingCard.starter_rating == 1)),
+            PitchingCard.select().join(Player).where(
+                (PitchingCard.player << backup_players) & (PitchingCard.closer_rating >= 1) &
+                (PitchingCard.starter_rating == 1)),
+            PitchingCard.select().join(Player).where(
+                (PitchingCard.player << backup_players) & (PitchingCard.starter_rating < 4))
+        ]:
+            all_relievers = sort_pitchers(query)
+
+            if all_relievers is not None:
+                this_player_id = all_relievers.iloc[0].player
+                this_player = model_to_dict(Player.get_by_id(this_player_id), recurse=False)
+                db.close()
+                return this_player
+
+    elif need == 'setup':
+        for query in [PitchingCard.select().join(Player).where(
+                (PitchingCard.player << legal_players) & (PitchingCard.starter_rating == 1)),
+            PitchingCard.select().join(Player).where(
+                (PitchingCard.player << backup_players) & (PitchingCard.starter_rating < 4))
+        ]:
+            all_relievers = sort_pitchers(query)
+
+            if all_relievers is not None and len(all_relievers.index) >= 2:
+                this_player_id = all_relievers.iloc[1].player
+                this_player = model_to_dict(Player.get_by_id(this_player_id), recurse=False)
+                db.close()
+                return this_player
+
+    elif need == 'length' or len(used_pitcher_ids) > 4:
+        for query in [PitchingCard.select().join(Player).where(
+                (PitchingCard.player << legal_players) & (PitchingCard.relief_rating >= 3) &
+                (PitchingCard.starter_rating < 4)),
+            PitchingCard.select().join(Player).where(
+                (PitchingCard.player << legal_players) & (PitchingCard.relief_rating >= 2) &
+                (PitchingCard.starter_rating < 4)),
+            PitchingCard.select().join(Player).where(
+                (PitchingCard.player << backup_players) & (PitchingCard.relief_rating >= 2) &
+                (PitchingCard.starter_rating < 4))
+        ]:
+            all_relievers = sort_pitchers(query)
+
+            if all_relievers is not None:
+                this_player_id = all_relievers.iloc[0].player
+                this_player = model_to_dict(Player.get_by_id(this_player_id), recurse=False)
+                db.close()
+                return this_player
+
+    elif need == 'middle':
+        for query in [PitchingCard.select().join(Player).where(
+                (PitchingCard.player << legal_players) & (PitchingCard.starter_rating == 1)),
+            PitchingCard.select().join(Player).where(
+                (PitchingCard.player << backup_players) & (PitchingCard.starter_rating < 4))
+        ]:
+            all_relievers = sort_pitchers(query)
+
+            if all_relievers is not None and len(all_relievers.index) >= 3:
+                this_player_id = all_relievers.iloc[2].player
+                this_player = model_to_dict(Player.get_by_id(this_player_id), recurse=False)
+                db.close()
+                return this_player
+
+    all_relievers = sort_pitchers(
+        PitchingCard.select().join(Player).where((PitchingCard.player << backup_players))
+    )
+
+    if all_relievers is not None:
+        this_player_id = all_relievers.iloc[len(all_relievers.index) - 1].player
+        this_player = model_to_dict(Player.get_by_id(this_player_id), recurse=False)
+        db.close()
+        return this_player
+
+
 @router.get('/{team_id}/buy/players')
 async def team_buy_players(team_id: int, ids: str, ts: str):
     try: