score.py

def get_valid_filename(s):
    s = str(s).strip().replace(' ', '_')
    return re.sub(r'(?u)[^-\w.]', '', s)


def call(fn, refresh=False, *args, **kwargs):
    filepath = f'{cache_dir}{fn_dir}{get_valid_filename(fn.__name__)}_{get_valid_filename(str(args))}_' \
        f'{get_valid_filename(kwargs)}'
    # pathlib.Path(filepath).mkdir(parents=True, exist_ok=True)

    if os.path.exists(f'{filepath}.json.gz') and not refresh:
        with gzip.open(f'{filepath}.json.gz', 'rb') as f:
            content = json.loads(f.read())

        return content
    else:
        data = fn(*args, **kwargs)
        with gzip.open(f'{filepath}.json.gz', 'wb+') as f:
            f.write(json.dumps(data).encode())

        if isinstance(data, tbapy.models._base_model_class):
            data = dict(data)

        return data


def score_team_event(team_number, event_key, refresh=False, wk=5):
    event_blob = call(tba.event, event=event_key)
    try:
        if (wk <= 7 and event_blob['week'] is None) or event_blob['week'] >= wk:
            return 0, 0, 0, 0, 0
    except:
        print(f'\tuhh weird error with {team_number} at {event_key}')
        return 0, 0, 0, 0, 0
    team_key = f'frc{team_number}'
    if event_blob['week'] is not None:  # not champs
        award_pt_map = {
            chairmans: 60,
            engineering_inspiration: 45,
            rookie_all_star: 25,
            rookie_inspiration: 15,
            autonomous: 20,
            creativity: 20,
            innovation_in_control: 20,
            industrial_design: 20,
            engineering_excellence: 20,
            quality: 20,
            deans_list: 5,
            woodie_flowers: 10,
            entrepreneurship: 5,
            gracious_professionalism: 5,
            imagery: 5,
            highest_rookie_seed: 5,
            judges: 5,
            safety: 5,
            spirit: 5,
        }
    else:
        award_pt_map = {
            chairmans: 110,
            chairmans_finalist: 90,
            engineering_inspiration: 60,
            rookie_all_star: 35,
            rookie_inspiration: 20,
            autonomous: 30,
            creativity: 30,
            innovation_in_control: 30,
            industrial_design: 30,
            engineering_excellence: 30,
            quality: 30,
            deans_list: 15,
            woodie_flowers: 30,
            entrepreneurship: 10,
            gracious_professionalism: 10,
            imagery: 10,
            highest_rookie_seed: 10,
            judges: 10,
            safety: 10,
            spirit: 10,
        }

    award_pts = 0
    event_awards = call(tba.event_awards, event=event_key, refresh=refresh)
    for award in event_awards:
        for recipient in award['recipient_list']:
            if recipient['team_key'] == team_key:
                award_pts += award_pt_map.get(award['award_type'], 0)

    try:
        district_pts = call(tba.event_district_points, event=event_key, refresh=refresh)
    except TypeError:
        district_pts = {'qual_points': 0, 'alliance_points': 0, 'elim_points': 0}
    else:
        if district_pts is None or not district_pts['points']:
            district_pts = {'qual_points': 0, 'alliance_points': 0, 'elim_points': 0}
        else:
            try:
                district_pts = district_pts['points'][team_key]
            except KeyError:
                district_pts = {'qual_points': 0, 'alliance_points': 0, 'elim_points': 0}

    qual_pts = district_pts['qual_points']
    picking_pts = district_pts['alliance_points']
    # elim_pts = district_pts['elim_points']

    # force elims points
    elim_pts = 0
    matches = call(tba.event_matches, event=event_key, refresh=refresh)
    for match in matches:
        if match['comp_level'] == 'qm':
            continue
        for color in ['blue', 'red']:
            if team_key in match['alliances'][color]['team_keys']:
                if match['winning_alliance'] is not None and match['winning_alliance'] == color:
                    elim_pts += 5

    return qual_pts, picking_pts, elim_pts, award_pts, qual_pts + picking_pts + elim_pts + award_pts



def parse_big_spreadsheet():
    filename = '2018-2019 SLFF Draft Spreadsheet - Draft Results.tsv'

    regional_tier_player_map = {}
    district_player_map = {}

    with open(filename, 'r') as big_sheet_file:
        reader = DictReader(big_sheet_file, delimiter='\t')
        next(reader)
        for row in reader:
            player = row['Player']
            tier = row['Tier']
            event_key = row['event code']
            event_name = row['Event']

            if len(event_key) == 0:
                continue

            picks = {}
            for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]:
                key_str = f'Round {i}' if i <= 3 else f'[Round {i}]'
                pick = row[key_str]
                if len(pick) == 0:
                    break
                else:
                    if pick.lower() == 'coi':
                        picks[i] = None
                    else:
                        picks[i] = int(pick)
            if not event_key.startswith('2019'):
                if event_key not in district_player_map:
                    district_player_map[event_key] = {}

                district_player_map[event_key][player] = picks
            else:
                if event_key not in regional_tier_player_map:
                    regional_tier_player_map[event_key] = {}
                if tier not in regional_tier_player_map[event_key]:
                    regional_tier_player_map[event_key][tier] = {}

                regional_tier_player_map[event_key][tier][player] = picks

    return regional_tier_player_map, district_player_map


spreadsheet_to_district_key = {
    'TEXAS': 'tx',
    'NE': 'ne',
    'ONT': 'ont',
    'PNW': 'pnw',
    'PCH': 'pch',
    'CHS': 'chs',
    'IN': 'in',
    'NC': 'fnc',
    'MAR': 'fma',
    'ISR': 'isr',
    'FIM': 'fim'
}


def score_slff():
    current_week = 5
    scores = {}
    regional_tier_players_picks, district_players_picks = parse_big_spreadsheet()
    # regional_tier_players_picks, district_players_picks = parse_ffai_spreadsheet()
    breakdown_table = []

    refreshed = set()
    refresh = True
    blacklist = [
        # '2019tuis2'
    ]
    refresh_since_week = 4

    score_cache = defaultdict(lambda: 0)

    for event_key, tier_players_picks in regional_tier_players_picks.items():
        # print(event_key)
        print(event_key)
        event_info = call(tba.event, event=event_key)
        if event_info['week'] >= current_week or event_info['key'] in blacklist:
            continue

        for tier, players_picks in tier_players_picks.items():
            for player, picks in players_picks.items():
                for rnd, team in picks.items():
                    if team is not None:
                        if player not in scores:
                            scores[player] = {'count': 0, 'points': 0}

                        # if (player, event_key) not in row_holder:
                        #     row_holder[(player, event_key)] = [event_key, player]

                        results = score_team_event(team,
                                                   event_key,
                                                   refresh=refresh and event_key not in refreshed and
                                                           event_info['week'] + 1 >= refresh_since_week
                                                   )
                        refreshed.add(event_key)
                        breakdown_table.append([player, team, event_key] + list(results))
                        # row_holder[(player, event_key)].extend([team, results[-1]])
                        if results[-1] != 0:
                            scores[player]['count'] += 1
                            scores[player]['points'] += results[-1]
                        score_cache[(team, event_key)] = results[-1]

    # player_team_plays = defaultdict(lambda: 0)
    # indiana_tracker = defaultdict(lambda: False)
    # for district_name, players_picks in district_players_picks.items():
    #     dkey = spreadsheet_to_district_key.get(district_name, district_name)
    #     district_rankings = call(tba.district_rankings, district=f'2019{dkey}', refresh=refresh)
    #     for district_ranking in district_rankings:
    #         team_key = district_ranking['team_key']
    #         team_no = int(team_key[3:])
    #         for player, picks in players_picks.items():
    #             if team_no in picks.values():
    #                 for district_event in district_ranking['event_points']:
    #                     event_key = district_event['event_key']
    #                     if event_key in blacklist:
    #                         continue
    #                     if player_team_plays[(player, team_key)] == 2:
    #                         break
    #                     else:
    #                         # waiver logic
    #                         # event = call(tba.event, event=event_key)
    #                         # score_normal = True
    #                         # for waiver_week, data_layer_1 in swaps.items():
    #                         #     if player in data_layer_1:
    #                         #         if dkey in data_layer_1[player]:
    #                         #             for swap in data_layer_1[player][dkey]:
    #                         #                 swap_in = swap['in']
    #                         #                 swap_out = swap['out']
    #                         #
    #                         #                 if team_no in [swap_in, swap_out]:
    #                         #                     score_normal = False
    #                         #                     if event['week'] + 1 <= waiver_week:
    #                         #                         results = score_team_event(
    #                         #                             swap_out,
    #                         #                             event_key,
    #                         #                             refresh=refresh and call(tba.event, event=event_key)[
    #                         #                                 'week'] + 1 >= refresh_since_week
    #                         #                         )
    #                         #                     else:
    #                         #                         results = score_team_event(
    #                         #                             swap_in,
    #                         #                             event_key,
    #                         #                             refresh=refresh and call(tba.event, event=event_key)[
    #                         #                                 'week'] + 1 >= refresh_since_week
    #                         #                         )
    #
    #                         player_team_plays[(player, team_key)] += 1
    #                         results = score_team_event(team_no,
    #                                                    event_key,
    #                                                    refresh=refresh and call(tba.event, event=event_key)[
    #                                                        'week'] + 1 >= refresh_since_week
    #                                                    )
    #
    #                         breakdown_table.append([player, team_no, event_key] + list(results))
    #                         if results[-1] != 0:
    #                             if not (dkey.lower() == 'in' and indiana_tracker[(team_no, event_key)] is True):
    #                                 score_cache[(team_no, dkey)] += results[-1]
    #                                 if dkey.lower() == 'in':
    #                                     indiana_tracker[(team_no, event_key)] = True
    #                             scores[player]['count'] += 1
    #                             scores[player]['points'] += results[-1]
    #                         # if (player, dkey) not in row_holder:
    #                         #     row_holder[(player, dkey)] = [dkey, player]
    #                         # if int(team_key[3:]) not in district_team_total_pts:
    #                         #     district_team_total_pts[int(team_key[3:])] = 0
    #                         # district_team_total_pts[int(team_key[3:])] += pts

    filename = '2018-2019 SLFF Draft Spreadsheet - (Unofficial) District Results.tsv'

    with open(filename, 'r') as big_sheet_file:
        reader = csv.reader(big_sheet_file, delimiter='\t')
        next(reader)
        next(reader)
        for row in reader:
            c = 4
            for i in range(1, 13):
                for slot in [1, 2]:
                    # cur_team = row[f'Team {i}-{slot}']
                    cur_team = row[c]
                    # cur_event = row[f'Event {i}-{slot}']
                    cur_event = row[c + 1]
                    c += 3
                    if cur_team in ['', '???']:
                        continue
                    if cur_event == '':
                        continue
                    pts = int(row[c - 1])
                    if pts == 0:
                        continue

                    scores[row[2]]['count'] += 1
                    scores[row[2]]['points'] += pts

    table = []
    for player, data in sorted(scores.items(), key=lambda t: -t[1]['points']):  # / t[1]['count']):
        avg = round(data['points'] / data['count'], 1)
        table.append([player, avg, data['points'], data['count']])

    print(tabulate(table, headers=['Team', 'Avg', 'Pts', 'Cnt'], tablefmt='presto'))

    breakdown_table.sort(key=lambda t: (t[2], -t[-1]))
    with open('test.html', 'w+') as f:
        f.write(tabulate(breakdown_table, headers=['Team', 'Team', 'Event', 'Qual', 'Pick', 'Elim', 'Award', 'Total'],
                         tablefmt='html'))

    rows = []
    for event_key, tier_players_picks in regional_tier_players_picks.items():
        for tier, players_picks in tier_players_picks.items():
            for player, picks in players_picks.items():
                new_row = [event_key, call(tba.event, event=event_key)['short_name'], tier, player]
                p_event_tot = 0
                for rnd, team in sorted(picks.items(), key=lambda t: t[0]):
                    if team is not None:
                        results = score_cache.get((team, event_key), 0)
                        new_row.extend([team, results])
                        p_event_tot += results
                new_row.insert(4, p_event_tot)
                while len(new_row) < 29:
                    new_row.append('')

                rows.append(new_row)

    # for district_name, players_picks in district_players_picks.items():
    #     dkey = spreadsheet_to_district_key.get(district_name, district_name)
    #     for player, picks in players_picks.items():
    #         new_row = [dkey, district_name, '', player]
    #         district_total = 0
    #         for rnd, team in sorted(picks.items(), key=lambda t: t[0]):
    #             if team is not None:
    #                 results = score_cache.get((team, dkey), 0)
    #                 new_row.extend([team, results])
    #                 district_total += results
    #         new_row.insert(4, district_total)
    #         while len(new_row) < 29:
    #             new_row.append('')
    #         rows.append(new_row)

    rows.sort(key=lambda t: (t[0], -t[4]))
    headers = ['Key', 'Name', 'Tier', 'Team', 'Total']
    for i in range(1, 13):
        headers.append(f'Pick {i}')
        headers.append(f'Points {i}')

    with open('templates/slff_leaderboard.html', 'r') as template:
        with open('leaderboard.html', 'w+') as output:
            contents = template.readlines()
            contents = '\n'.join(contents)
            output.write(minify(Template(contents).render(rows=rows, headers=headers)))