paper-dynasty-card-creation/fix_cardpositions.py

"""
Fix script to regenerate cardpositions for cardset 27 batters.
This addresses the bug where batter positions were deleted but never recreated
due to script interruption on 2025-12-07.
"""
import asyncio
import pandas as pd

from db_calls import db_get, db_put, db_delete
from exceptions import logger
import defenders.calcs_defense as cde

# Configuration
CARDSET_ID = 27
DATA_INPUT_FILE_PATH = 'data-input/2005 Live Cardset/'


async def get_batters_from_api():
    """Fetch all batters (players with battingcards) from the API for cardset 27."""
    print(f'Fetching batters from cardset {CARDSET_ID}...')

    # Get all players in cardset
    resp = await db_get('players', params=[
        ('cardset_id', CARDSET_ID),
        ('short_output', True)
    ])

    if not resp or resp.get('count', 0) == 0:
        print('No players found!')
        return []

    # Filter to batters only (those with battingcard URLs)
    batters = [p for p in resp['players'] if 'batting' in p.get('image', '')]
    print(f'Found {len(batters)} batters')
    return batters


def calc_positions_for_batters(batters: list) -> pd.DataFrame:
    """Calculate position data for all batters using defense CSV files."""
    print(f'Loading defense CSV files from {DATA_INPUT_FILE_PATH}...')

    df_c = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_c.csv').set_index('key_bbref')
    df_1b = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_1b.csv').set_index('key_bbref')
    df_2b = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_2b.csv').set_index('key_bbref')
    df_3b = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_3b.csv').set_index('key_bbref')
    df_ss = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_ss.csv').set_index('key_bbref')
    df_lf = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_lf.csv').set_index('key_bbref')
    df_cf = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_cf.csv').set_index('key_bbref')
    df_rf = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_rf.csv').set_index('key_bbref')
    df_of = pd.read_csv(f'{DATA_INPUT_FILE_PATH}defense_of.csv').set_index('key_bbref')

    all_pos = []
    season_pct = 1.0

    for batter in batters:
        key_bbref = batter.get('bbref_id')
        player_id = batter.get('player_id')
        player_name = batter.get('p_name', 'Unknown')

        if not key_bbref:
            print(f'  Warning: No bbref_id for player {player_id} ({player_name})')
            continue

        no_data = True

        # Process infield positions
        for pos_df, position in [(df_1b, '1b'), (df_2b, '2b'), (df_3b, '3b'), (df_ss, 'ss')]:
            if key_bbref in pos_df.index:
                try:
                    if 'bis_runs_total' in pos_df.columns:
                        average_range = (int(pos_df.at[key_bbref, 'tz_runs_total']) +
                                        int(pos_df.at[key_bbref, 'bis_runs_total']) +
                                        min(
                                            int(pos_df.at[key_bbref, 'tz_runs_total']),
                                            int(pos_df.at[key_bbref, 'bis_runs_total'])
                                        )) / 3
                    else:
                        average_range = pos_df.at[key_bbref, 'tz_runs_total']

                    if float(pos_df.at[key_bbref, 'Inn_def']) >= 10.0:
                        all_pos.append({
                            "player_id": player_id,
                            "position": position.upper(),
                            "innings": float(pos_df.at[key_bbref, 'Inn_def']),
                            "range": cde.get_if_range(
                                pos_code=position,
                                tz_runs=round(average_range),
                                r_dp=0,
                                season_pct=season_pct
                            ),
                            "error": cde.get_any_error(
                                pos_code=position,
                                errors=int(pos_df.at[key_bbref, 'E_def']),
                                chances=int(pos_df.at[key_bbref, 'chances']),
                                season_pct=season_pct
                            )
                        })
                        no_data = False
                except Exception as e:
                    logger.info(f'Infield position failed for {player_name}: {e}')

        # Process outfield positions
        of_arms = []
        of_payloads = []
        for pos_df, position in [(df_lf, 'lf'), (df_cf, 'cf'), (df_rf, 'rf')]:
            if key_bbref in pos_df.index:
                try:
                    if 'bis_runs_total' in pos_df.columns:
                        average_range = (int(pos_df.at[key_bbref, 'tz_runs_total']) +
                                        int(pos_df.at[key_bbref, 'bis_runs_total']) +
                                        min(
                                            int(pos_df.at[key_bbref, 'tz_runs_total']),
                                            int(pos_df.at[key_bbref, 'bis_runs_total'])
                                        )) / 3
                    else:
                        average_range = pos_df.at[key_bbref, 'tz_runs_total']

                    if float(pos_df.at[key_bbref, 'Inn_def']) >= 10.0:
                        of_payloads.append({
                            "player_id": player_id,
                            "position": position.upper(),
                            "innings": float(pos_df.at[key_bbref, 'Inn_def']),
                            "range": cde.get_of_range(
                                pos_code=position,
                                tz_runs=round(average_range),
                                season_pct=season_pct
                            )
                        })
                        of_run_rating = 'bis_runs_outfield' if 'bis_runs_outfield' in pos_df.columns else 'tz_runs_total'
                        of_arms.append(int(pos_df.at[key_bbref, of_run_rating]))
                        no_data = False
                except Exception as e:
                    logger.info(f'Outfield position failed for {player_name}: {e}')

        # Add arm/error to outfield positions
        if key_bbref in df_of.index and len(of_arms) > 0 and len(of_payloads) > 0:
            try:
                error_rating = cde.get_any_error(
                    pos_code='of',
                    errors=int(df_of.at[key_bbref, 'E_def']),
                    chances=int(df_of.at[key_bbref, 'chances']),
                    season_pct=season_pct
                )
                arm_rating = cde.arm_outfield(of_arms)
                for f in of_payloads:
                    f['error'] = error_rating
                    f['arm'] = arm_rating
                    all_pos.append(f)
            except Exception as e:
                logger.info(f'Outfield arm/error failed for {player_name}: {e}')

        # Process catcher
        if key_bbref in df_c.index:
            try:
                run_rating = 'bis_runs_catcher_sb' if 'bis_runs_catcher_sb' in df_c else 'tz_runs_catcher'

                if df_c.at[key_bbref, 'SB'] + df_c.at[key_bbref, 'CS'] == 0:
                    arm_rating = 3
                else:
                    arm_rating = cde.arm_catcher(
                        cs_pct=df_c.at[key_bbref, 'caught_stealing_perc'],
                        raa=int(df_c.at[key_bbref, run_rating]),
                        season_pct=season_pct
                    )

                if float(df_c.at[key_bbref, 'Inn_def']) >= 10.0:
                    all_pos.append({
                        "player_id": player_id,
                        "position": 'C',
                        "innings": float(df_c.at[key_bbref, 'Inn_def']),
                        "range": cde.range_catcher(
                            rs_value=int(df_c.at[key_bbref, 'tz_runs_catcher']),
                            season_pct=season_pct
                        ),
                        "error": cde.get_any_error(
                            pos_code='c',
                            errors=int(df_c.at[key_bbref, 'E_def']),
                            chances=int(df_c.at[key_bbref, 'chances']),
                            season_pct=season_pct
                        ),
                        "arm": arm_rating,
                        "pb": cde.pb_catcher(
                            pb=int(df_c.at[key_bbref, 'PB']),
                            innings=int(float(df_c.at[key_bbref, 'Inn_def'])),
                            season_pct=season_pct
                        ),
                        "overthrow": cde.ot_catcher(
                            errors=int(df_c.at[key_bbref, 'E_def']),
                            chances=int(df_c.at[key_bbref, 'chances']),
                            season_pct=season_pct
                        )
                    })
                    no_data = False
            except Exception as e:
                logger.info(f'Catcher position failed for {player_name}: {e}')

        # DH fallback if no defensive data
        if no_data:
            all_pos.append({
                "player_id": player_id,
                "position": 'DH',
                "innings": 100  # Default innings for DH
            })

    print(f'Calculated {len(all_pos)} position records for {len(batters)} batters')
    return pd.DataFrame(all_pos)


async def delete_batter_positions(batter_player_ids: list):
    """Delete existing batter cardpositions for cardset 27."""
    print(f'Fetching existing cardpositions for cardset {CARDSET_ID}...')

    existing = await db_get('cardpositions', params=[('cardset_id', CARDSET_ID)])
    if not existing or existing.get('count', 0) == 0:
        print('No existing positions found')
        return 0

    # Only delete positions for batters (not pitchers)
    batter_ids_set = set(batter_player_ids)
    positions_to_delete = [
        p for p in existing['positions']
        if p['player']['player_id'] in batter_ids_set
    ]

    print(f'Found {len(positions_to_delete)} batter positions to delete (keeping pitcher positions)')

    deleted = 0
    for pos in positions_to_delete:
        try:
            await db_delete('cardpositions', object_id=pos['id'], timeout=1)
            deleted += 1
            if deleted % 50 == 0:
                print(f'  Deleted {deleted}/{len(positions_to_delete)} positions...')
        except Exception as e:
            print(f'  Warning: Failed to delete position {pos["id"]}: {e}')

    print(f'Deleted {deleted} batter positions')
    return deleted


async def post_positions(pos_df: pd.DataFrame):
    """POST the new cardpositions to the API."""
    all_pos = []

    for _, row in pos_df.iterrows():
        clean_row = row.dropna()
        new_val = clean_row.to_dict()
        new_val['player_id'] = int(row['player_id'])
        all_pos.append(new_val)

    print(f'POSTing {len(all_pos)} cardpositions...')
    resp = await db_put('cardpositions', payload={'positions': all_pos}, timeout=10)

    if resp is not None:
        print(f'Successfully posted positions: {resp}')
        return True
    else:
        print('Failed to post positions!')
        return False


async def main():
    print('='*60)
    print('CARDPOSITIONS FIX SCRIPT')
    print('='*60)
    print(f'Target: Cardset {CARDSET_ID} (2005 Live)')
    print()

    # Step 1: Get batters from API
    batters = await get_batters_from_api()
    if not batters:
        print('No batters to process!')
        return

    batter_player_ids = [b['player_id'] for b in batters]

    # Step 2: Delete existing batter positions
    await delete_batter_positions(batter_player_ids)

    # Step 3: Calculate new positions
    pos_df = calc_positions_for_batters(batters)

    # Step 4: Post new positions
    success = await post_positions(pos_df)

    print()
    print('='*60)
    if success:
        print('FIX COMPLETE - Batter positions have been regenerated!')
    else:
        print('FIX FAILED - Check logs for errors')
    print('='*60)


if __name__ == '__main__':
    asyncio.run(main())