Major League Campaign update

Prep for flashback campaign

app/db_engine.py

@@ -41,7 +41,7 @@ CARDSETS = {
     'hall-of-fame': {
         'primary': [1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
     },
-    'tens': {
+    'flashback': {
         'primary': [11, 7, 6, 12],  # 2016, 2012, 2013, 2008, Mario
         'secondary': [13, 5]  # 2018, 2019
     },

app/routers_v2/cards.py

@@ -225,7 +225,7 @@ async def v1_cards_legal_check(
     all_cards = Card.select().where(Card.id << card_id)
 
     for x in all_cards:
-        if x.player.cardset_id not in CARDSETS[rarity_name]:
+        if x.player.cardset_id not in CARDSETS[rarity_name]['primary']:
             if x.player.p_name in x.player.description:
                 bad_cards.append(x.player.description)
             else:

app/routers_v2/teams.py

@@ -156,8 +156,82 @@ async def get_one_team(team_id, inc_packs: bool = True, csv: Optional[bool] = Fa
     return return_val
 
 
+def get_scouting_dfs(allowed_players, position: str):
+    positions = CardPosition.select().where(
+        (CardPosition.player << allowed_players) & (CardPosition.position == position)
+    )
+    pos_players = [x.player.player_id for x in positions]
+
+    all_cards = BattingCard.select().where(BattingCard.player << pos_players)
+    all_ratings = BattingCardRatings.select().where(BattingCardRatings.battingcard << all_cards)
+
+    vl_query = all_ratings.where(BattingCardRatings.vs_hand == 'L')
+    vr_query = all_ratings.where(BattingCardRatings.vs_hand == 'R')
+
+    vl_vals = [model_to_dict(x) for x in vl_query]
+    for x in vl_vals:
+        x.update(x['battingcard'])
+        x['player_id'] = x['battingcard']['player']['player_id']
+        x['player_name'] = x['battingcard']['player']['p_name']
+        x['rarity'] = x['battingcard']['player']['rarity']['name']
+        x['cardset_id'] = x['battingcard']['player']['cardset']['id']
+        x['cardset_name'] = x['battingcard']['player']['cardset']['name']
+        del x['battingcard'], x['player']
+
+    vr_vals = [model_to_dict(x) for x in vr_query]
+    for x in vr_vals:
+        x['player_id'] = x['battingcard']['player']['player_id']
+        del x['battingcard']
+
+    vl = pd.DataFrame(vl_vals)
+    vr = pd.DataFrame(vr_vals)
+
+    bat_df = pd.merge(vl, vr, on='player_id', suffixes=('_vl', '_vr')).set_index('player_id', drop=False)
+    logging.info(f'cols:\n{list(bat_df.columns)}')
+    series_list = []
+
+    series_list.append(pd.Series(
+        dict([(x.player.player_id, x.range) for x in positions]),
+        name=f'Range {position}'
+    ))
+    series_list.append(pd.Series(
+        dict([(x.player.player_id, x.error) for x in positions]),
+        name=f'Error {position}'
+    ))
+    if position in ['LF', 'CF', 'RF']:
+        series_list.append(pd.Series(
+            dict([(x.player.player_id, x.arm) for x in positions]),
+            name=f'Arm OF'
+        ))
+    elif position == 'C':
+        series_list.append(pd.Series(
+            dict([(x.player.player_id, x.arm) for x in positions]),
+            name=f'Arm C'
+        ))
+        series_list.append(pd.Series(
+            dict([(x.player.player_id, x.pb) for x in positions]),
+            name=f'PB C'
+        ))
+        series_list.append(pd.Series(
+            dict([(x.player.player_id, x.overthrow) for x in positions]),
+            name=f'Throw C'
+        ))
+
+    db.close()
+
+    def get_total_ops(df_data):
+        ops_vl = df_data['obp_vl'] + df_data['slg_vl']
+        ops_vr = df_data['obp_vr'] + df_data['slg_vr']
+        return (ops_vr + ops_vl + min(ops_vl, ops_vr)) / 3
+
+    logging.debug(f'series_list: {series_list}')
+    ratings = bat_df.join(series_list)
+    ratings['total_OPS'] = ratings.apply(get_total_ops, axis=1)
+    return ratings
+
+
 @router.get('/{team_id}/lineup/{difficulty_name}')
-async def get_team_lineup(team_id: int, difficulty_name: str, pitcher_name: str, d_rank: int = 5, o_rank: int = 5):
+async def get_team_lineup(team_id: int, difficulty_name: str, pitcher_name: str, build_type: str):
     """
     d_rank: int - 10: best overall, 9: prioritize range, 8: prioritize error
     """
@@ -173,7 +247,7 @@ async def get_team_lineup(team_id: int, difficulty_name: str, pitcher_name: str,
     # all_players = Player.select().where(
     #     (fn.Lower(Player.p_name) != pitcher_name.lower()) & (Player.mlbclub == this_team.lname)
     # )
-    all_players = Player.select().where(Player.mlbclub == this_team.lname)
+    all_players = Player.select().where(Player.franchise == this_team.lname)
 
     legal_players = all_players.where(Player.cardset_id << CARDSETS[difficulty_name]['primary'])
     if 'secondary' in CARDSETS[difficulty_name]:
@@ -181,9 +255,9 @@ async def get_team_lineup(team_id: int, difficulty_name: str, pitcher_name: str,
     else:
         backup_players = None
 
-    logging.debug(f'legal_players: {legal_players.count()}')
+    logging.info(f'legal_players: {legal_players.count()}')
     if backup_players is not None:
-        logging.debug(f'backup_players: {backup_players.count()}')
+        logging.info(f'backup_players: {backup_players.count()}')
     player_names = []
     starting_nine = {
         'C': {'player': None, 'vl': None, 'vr': None, 'ops': 0},
@@ -233,8 +307,10 @@ async def get_team_lineup(team_id: int, difficulty_name: str, pitcher_name: str,
                     except AttributeError as e:
                         logging.debug(f'Could not find batting lines')
                     else:
-                        starting_nine['DH']['vl'] = vl
+                        # starting_nine[position]['vl'] = vl
-                        starting_nine['DH']['vr'] = vr
+                        # starting_nine[position]['vr'] = vr
+                        starting_nine[position]['vl'] = vl['obp'] + vl['slg']
+                        starting_nine[position]['vr'] = vr['obp'] + vr['slg']
                         starting_nine['DH']['ops'] = total_ops
                         player_names.append(x.p_name)
                         break
@@ -252,8 +328,8 @@ async def get_team_lineup(team_id: int, difficulty_name: str, pitcher_name: str,
                             logging.debug(f'Could not find batting lines')
                         else:
                             vl, vr, total_ops = get_bratings(x.player_id)
-                            starting_nine['DH']['vl'] = vl
+                            starting_nine[position]['vl'] = vl['obp'] + vl['slg']
-                            starting_nine['DH']['vr'] = vr
+                            starting_nine[position]['vr'] = vr['obp'] + vr['slg']
                             starting_nine['DH']['ops'] = total_ops
                             player_names.append(x.p_name)
                             break
@@ -264,18 +340,9 @@ async def get_team_lineup(team_id: int, difficulty_name: str, pitcher_name: str,
             )
             backup_group = CardPosition.select().where(
                 (CardPosition.position == position) & (CardPosition.player << backup_players)
-            )
+            ).order_by(CardPosition.innings.desc())
             if difficulty_name in ['minor-league', 'gauntlet-3']:
                 pos_group = pos_group.order_by(CardPosition.innings.desc())
-            elif d_rank == 10:
-                pos_group = pos_group.order_by((CardPosition.range * 5) + CardPosition.error)
-            elif d_rank == 9:
-                pos_group = pos_group.order_by(CardPosition.range)
-            elif d_rank == 8:
-                pos_group = pos_group.order_by(CardPosition.error.desc())
-
-            logging.debug(f'pos_group: {pos_group}\n{starting_nine}\n{player_names}\n\n')
-            if difficulty_name in ['minor-league', 'gauntlet-3']:
                 for x in pos_group:
                     logging.debug(f'checking {x.player.p_name} for {position}')
                     if x.player.p_name not in player_names and x.player.p_name.lower() != pitcher_name:
@@ -284,23 +351,66 @@ async def get_team_lineup(team_id: int, difficulty_name: str, pitcher_name: str,
                         vl, vr, total_ops = get_bratings(x.player.player_id)
                         starting_nine[position]['vl'] = vl
                         starting_nine[position]['vr'] = vr
+                        # starting_nine[position]['vl'] = vl.obp_vl + vl.slg_vl
+                        # starting_nine[position]['vr'] = vr.obp_vr + vr.slg_vr
                         starting_nine[position]['ops'] = total_ops
                         player_names.append(x.player.p_name)
                         break
 
-                if starting_nine[position]['player'] is None:
+            elif difficulty_name in ['major-league', 'tens', 'hall-of-fame']:
-                    for x in backup_group:
+                logging.debug(f'entering difficulty: {difficulty_name}')
-                        logging.debug(f'checking {x.player.p_name} for {position}')
+                eligible_cards = get_scouting_dfs(legal_players, position)
-                        if x.player.p_name not in player_names and x.player.p_name.lower() != pitcher_name:
+                logging.debug(f'got dataframe:\n{eligible_cards}')
-                            logging.debug(f'adding!')
+                # if position == '1B':
-                            starting_nine[position]['player'] = model_to_dict(x.player)
+                #     return Response(content=eligible_cards.to_csv(index=False), media_type='text/csv')
-                            vl, vr, total_ops = get_bratings(x.player.player_id)
+
-                            starting_nine[position]['vl'] = vl
+                def rank_cards(df_data):
-                            starting_nine[position]['vr'] = vr
+                    if position in ['C', 'SS', '2B', 'CF']:
-                            starting_nine[position]['ops'] = total_ops
+                        r_mult = 0.05
-                            player_names.append(x.player.p_name)
+                        e_mult = -0.01
+                    else:
+                        r_mult = 0.025
+                        e_mult = -0.005
+
+                    r_mod = (3 - df_data[f'Range {position}']) * r_mult
+                    e_mod = df_data[f'Error {position}'] * e_mult
+
+                    logging.debug(f'{df_data.player_name} total OPS: {df_data.total_OPS} / '
+                                 f'final OPS: {df_data.total_OPS + r_mod + e_mod}')
+                    return df_data['total_OPS'] + r_mod + e_mod
+
+                if len(eligible_cards.index) >= 1:
+                    eligible_cards['final_ops'] = eligible_cards.apply(rank_cards, axis=1)
+                    logging.debug(f'final_ops:\n{eligible_cards["final_ops"]}')
+                    eligible_cards.sort_values(by=['final_ops'], ascending=False, inplace=True)
+
+                    this_row = None
+                    for x in range(len(eligible_cards.index)):
+                        if eligible_cards.iloc[x].player_name not in player_names:
+                            this_row = eligible_cards.iloc[x]
                             break
 
+                    if this_row is not None:
+                        starting_nine[position]['player'] = model_to_dict(Player.get_by_id(this_row.player_id))
+                        starting_nine[position]['vl'] = this_row.obp_vl + this_row.slg_vl
+                        starting_nine[position]['vr'] = this_row.obp_vr + this_row.slg_vr
+                        starting_nine[position]['ops'] = this_row.total_OPS
+                        player_names.append(this_row.player_name)
+
+            logging.debug(f'pos_group: {pos_group}\n{starting_nine}\n{player_names}\n\n')
+            if starting_nine[position]['player'] is None:
+                for x in backup_group:
+                    logging.info(f'checking {x.player.p_name} for {position}')
+                    if x.player.p_name not in player_names and x.player.p_name.lower() != pitcher_name:
+                        logging.debug(f'adding!')
+                        starting_nine[position]['player'] = model_to_dict(x.player)
+                        vl, vr, total_ops = get_bratings(x.player.player_id)
+                        starting_nine[position]['vl'] = vl['obp'] + vl['slg']
+                        starting_nine[position]['vr'] = vr['obp'] + vr['slg']
+                        starting_nine[position]['ops'] = total_ops
+                        player_names.append(x.player.p_name)
+                        break
+
     # all_bcards = BattingCard.select().where(BattingCard.player << starting_nine.values())
     # all_ratings = BattingCardRatings.select().where(BattingCardRatings.battingcard << all_bcards)
     #