Beispiel #1
0
def value_pool_hitting(league, player_pool, type):
    from datetime import date
    from general import utilities
    from analysis import calculations
    from analysis import player_pool_stats

    assert type in ['B', 'P']
    player_pool['type'] = type

    # calc % of season left for determining PAs for sample threshold
    f_date = date(2021, 4, 1)
    l_date = date(2021, 9, 30)
    season_length = l_date - f_date
    pct_through = (l_date - date.today()).days / (l_date - f_date).days

    #player_pool['sample'] = player_pool['pa'] > 500*pct_through
    player_pool['sample'] = True
    for run in range(1, 3):
        player_pool = calculations.calc_z(df=player_pool,
                                          ls=league,
                                          type='hitting')
        player_pool['sample'] = player_pool.apply(lambda row: row.zar > 0,
                                                  axis=1)

    columns = [
        'name', 'fg_id', 'type', 'elig', 'pa', league.hitting_counting_stats,
        league.hitting_rate_stats, 'zar', 'value'
    ]
    columns = utilities.flatten(columns)
    player_pool = player_pool[columns]
    return player_pool
Beispiel #2
0
def create_pitcher_valuations(league, stats):
    from general import utilities
    from analysis import calculations
    from analysis import player_pool_stats

    assert league.league_name in ['SoS', 'Legacy']
    pitchers = stats
    pitchers['type'] = 'P'

    pitchers['sample'] = pitchers.apply(lambda row: not (row['era'] == float(
        'inf') or row['whip'] == float('inf')),
                                        axis=1)

    for run in range(1, 3):
        pitchers = calculations.calc_z(df=pitchers, ls=league, type='pitching')
        pitchers['sample'] = pitchers.apply(lambda row: row.zar > 0, axis=1)

    columns = [
        'name', 'fg_id', 'team', 'type', 'elig', 'ip',
        league.pitching_counting_stats, league.pitching_rate_stats, 'zar',
        'value', 'zar_skills', 'rank_sp', 'rank_rp'
    ]
    columns = utilities.flatten(columns)
    pitchers = pitchers[columns]
    return pitchers
Beispiel #3
0
def create_hitter_valuations(league, stats):
    from general import utilities
    from analysis import calculations
    from analysis import player_pool_stats

    assert league.league_name in ['SoS', 'Legacy']
    hitters = stats
    hitters['type'] = 'B'

    pa_threshold = hitters['pa'].quantile(.9)
    hitters['sample'] = hitters.apply(lambda row: row['pa'] > pa_threshold,
                                      axis=1)

    for run in range(1, 3):
        hitters = calculations.calc_z(df=hitters, ls=league, type='batting')
        hitters['sample'] = hitters.apply(lambda row: row.zar > 0, axis=1)

    columns = [
        'name', 'fg_id', 'team', 'type', 'elig', 'pa',
        league.hitting_counting_stats, league.hitting_rate_stats, 'zar',
        'value'
    ]
    columns = utilities.flatten(columns)
    hitters = hitters[columns]
    hitters.reset_index(inplace=True)
    return hitters
Beispiel #4
0
def create_combined_pitcher_valuations(league):
    from general import utilities
    from analysis import calculations
    from analysis import player_pool_stats

    assert league.league_name in ['SoS', 'Legacy']
    combined_pitchers = player_pool_stats.create_combined_pitchers(league)
    combined_pitchers['type'] = 'P'

    combined_pitchers['sample'] = True
    for run in range(1, 3):
        combined_pitchers = calculations.calc_z(df=combined_pitchers,
                                                ls=league,
                                                type='pitching')
        combined_pitchers['sample'] = combined_pitchers.apply(
            lambda row: row.zar > 0, axis=1)

    columns = [
        'name', 'fg_id', 'team', 'type', 'elig', 'ip',
        league.pitching_counting_stats, league.pitching_rate_stats, 'zar',
        'value', 'zar_skills', 'rank_sp', 'rank_rp'
    ]
    columns = utilities.flatten(columns)
    combined_pitchers = combined_pitchers[columns]
    return combined_pitchers
Beispiel #5
0
def create_combined_hitter_valuations(league):
    from datetime import date
    from general import utilities
    from analysis import calculations
    from analysis import player_pool_stats

    assert league.league_name in ['SoS', 'Legacy']
    combined_hitters = player_pool_stats.create_combined_hitters(league)
    combined_hitters['type'] = 'B'

    # calc % of season left for determining PAs for sample threshold
    f_date = date(2021, 4, 1)
    l_date = date(2021, 9, 30)
    season_length = l_date - f_date
    pct_through = (l_date - date.today()).days / (l_date - f_date).days

    combined_hitters['sample'] = combined_hitters['pa'] > 500 * pct_through
    for run in range(1, 3):
        combined_hitters = calculations.calc_z(df=combined_hitters,
                                               ls=league,
                                               type='hitting')
        combined_hitters['sample'] = combined_hitters.apply(
            lambda row: row.zar > 0, axis=1)

    combined_hitters_600 = player_pool_stats.create_combined_hitters(league,
                                                                     pa=600)
    combined_hitters_600['type'] = 'B'
    combined_hitters_600 = combined_hitters_600.merge(
        combined_hitters[['fg_id', 'sample']], how='left', on='fg_id')
    combined_hitters_600 = calculations.calc_z(df=combined_hitters_600,
                                               ls=league,
                                               type='hitting')
    combined_hitters = combined_hitters.merge(
        combined_hitters_600[['fg_id',
                              'value']].rename(columns={'value': 'value_600'}),
        how='left',
        on='fg_id')

    columns = [
        'name', 'fg_id', 'type', 'elig', 'pa', league.hitting_counting_stats,
        league.hitting_rate_stats, 'zar', 'value', 'value_600'
    ]
    columns = utilities.flatten(columns)
    combined_hitters = combined_hitters[columns]
    return combined_hitters