app.py

from pathlib import Path
from typing import Optional, Tuple

import gradio as gr
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import plotly.graph_objects as go
import seaborn as sns
from wordcloud import WordCloud


def _rename_columns(df: pd.DataFrame, is_tournament: bool) -> pd.DataFrame:
    columns = {
        "Rating": "rating",
        "Result": "result",
        "Scores": "scores",
        "Opponent": "opponent",
        "OpponentRating": "opponent_rating",
    }

    if is_tournament:
        columns.update({
            "TournamentStartDate": "tournament_start_date",
            "TournamentEndDate": "tournament_end_date",
            " Touranament": "tournament",
        })
    else:
        columns.update({
            "EventDate": "event_date",
            "LeagueName": "league_name"
        })

    return df.rename(columns=columns)


def _fix_dtypes(df: pd.DataFrame, is_tournament: bool) -> pd.DataFrame:
    if is_tournament:
        df["tournament_start_date"] = pd.to_datetime(df["tournament_start_date"])
        df["tournament_end_date"] = pd.to_datetime(df["tournament_end_date"])
        df["tournament"] = df["tournament"].astype('category')
    else:
        df["event_date"] = pd.to_datetime(df["event_date"])
        df["league_name"] = df["league_name"].astype('string')

    df["rating"] = df["rating"].astype('int')
    df["result"] = df["result"].astype('category')
    df["scores"] = df["scores"].astype('string')
    df["opponent"] = df["opponent"].astype('category')
    df["opponent_rating"] = df["opponent_rating"].astype('int')

    return df

def snake_case_to_human_readable(s: str) -> str:
    return " ".join(s.capitalize().split("_"))

def make_df_columns_readable(df: Optional[pd.DataFrame], is_tournament: bool) -> Optional[pd.DataFrame]:
    """Make a data frame's columns human-readable."""
    if df is None:
        return None

    nat_to_none = lambda x: None if x == "NaT" else x
    if is_tournament:
        if "tournament_start_date" in df.columns and "tournament_end_date" in df.columns:
            df['tournament_start_date'] = df['tournament_start_date'].dt.date.astype(str).apply(nat_to_none)
            df['tournament_end_date'] = df['tournament_end_date'].dt.date.astype(str).apply(nat_to_none)

            def create_date(tournament_start_date, tournament_end_date):
                missing_start_date = tournament_start_date is None
                missing_end_date = tournament_end_date is None
                if not missing_start_date and not missing_end_date:
                    if tournament_start_date is not tournament_end_date:
                        return ' - '.join((tournament_start_date, tournament_end_date))
                    else:
                        return tournament_start_date
                else:
                    return tournament_start_date if missing_end_date else tournament_end_date

            df["date"] = df.apply(lambda row: create_date(row['tournament_start_date'], row['tournament_end_date']), axis=1)
            df = df.drop(columns=["tournament_start_date", "tournament_end_date"])

            # Move date to the front.
            columns = list(df.columns)
            columns.insert(0, columns.pop(columns.index("date")))
            df = df.loc[:, columns]
    else:
        if "event_date" in df.columns:
            df['event_date'] = df['event_date'].dt.date.astype(str).apply(nat_to_none)
        df = df.rename(columns={"league_name": "league"})

    df = df.rename(columns=lambda c: snake_case_to_human_readable(c))
    return df

def _check_match_type(match_type: str) -> str:
    allowed_match_types = {"tournament", "league"}
    if match_type not in allowed_match_types:
        raise ValueError(
            f"The only supported match types are {allowed_match_types}. Found match type of '{match_type}'.")
    return match_type


def get_num_competitions_played(df: pd.DataFrame, is_tournament: bool) -> int:
    key_name = "tournament_end_date" if is_tournament else "event_date"
    return df[key_name].nunique()


def get_current_rating(df: pd.DataFrame) -> int:
    return df.rating.iloc[0]


def get_max_rating(df: pd.DataFrame) -> int:
    return df.rating.max()


def get_matches_per_competition_fig(df: pd.DataFrame, is_tournament: bool):
    fig = plt.figure()
    plt.title('Matches per competition')
    sns.histplot(df.groupby('tournament' if is_tournament else "event_date").size())
    plt.xlabel('Number of matches in competition')
    return fig


def get_competition_name_word_cloud_fig(df: pd.DataFrame, is_tournament: bool):
    fig = plt.figure()
    key_name = "tournament" if is_tournament else "league_name"
    wordcloud = WordCloud().generate(" ".join(df[key_name].values.tolist()))
    plt.imshow(wordcloud, interpolation='bilinear')
    plt.axis("off")
    return fig


def get_opponent_name_word_cloud_fig(df: pd.DataFrame):
    fig = plt.figure()
    wordcloud = WordCloud().generate(" ".join(df.opponent.values.tolist()))
    plt.imshow(wordcloud, interpolation='bilinear')
    plt.axis("off")
    return fig


def get_rating_over_time_fig(df: pd.DataFrame, is_tournament: bool):
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=df["tournament_end_date" if is_tournament else "event_date"],
                             y=df["rating"],
                             mode='lines+markers',
                             line=dict( width=0.9),
                             marker=dict(size=4))),

    fig.update_layout(
        title='Rating over time',
        xaxis_title='Competition date',
        yaxis_title='Rating',
        showlegend=False,
        template="plotly_white",
    )

    return fig


def get_max_abs_int(int_csv_str: str) -> int:
    """Get the max absolute value int from an int CSV."""
    ints = [abs(int(i.strip())) for i in int_csv_str.split(',') if i]
    return max(ints)


def get_match_with_longest_game(df: pd.DataFrame, is_tournament: bool) -> Optional[pd.DataFrame]:
    if not is_tournament:
        return None
    df_non_null = df.loc[~df.scores.isna()]
    return df_non_null.iloc[[df_non_null.scores.apply(get_max_abs_int).argmax()]]


def get_win_loss_record_str(group_df) -> str:
    if len(group_df) > 0:
        win_loss_counts = group_df.value_counts()
        n_wins = win_loss_counts.Won if hasattr(win_loss_counts, "Won") else 0
        n_losses = win_loss_counts.Lost if hasattr(win_loss_counts, "Lost") else 0
    else:
        n_wins = 0
        n_losses = 0

    return f"{n_wins}, {n_losses}"


def get_most_frequent_opponents(df: pd.DataFrame, top_n: int = 5) -> pd.DataFrame:
    df_with_opponents = df.loc[df.opponent != "-, -"]

    most_common_opponents_df = df_with_opponents.groupby('opponent').agg({"result": [get_win_loss_record_str, "size"]})
    most_common_opponents_df.columns = most_common_opponents_df.columns.get_level_values(1)
    most_common_opponents_df.rename({"get_win_loss_record_str": "Win/loss record", "size": "Number of matches"}, axis=1,
                                    inplace=True)
    most_common_opponents_df["Opponent"] = most_common_opponents_df.index
    return most_common_opponents_df.sort_values("Number of matches", ascending=False)[
        ["Opponent", "Number of matches", "Win/loss record"]].head(top_n)


def get_best_wins(df: pd.DataFrame, top_n: int = 5) -> pd.DataFrame:
    """Get the top-n wins sorted by opponent rating."""
    return df.loc[df.result == 'Won'].sort_values("opponent_rating", ascending=False).head(top_n)


def get_biggest_upsets(df: pd.DataFrame, top_n: int = 5) -> pd.DataFrame:
    """Get the top-n wins sorted by rating difference."""
    df['rating_difference'] = df['opponent_rating'] - df['rating']
    return df.loc[df.result == 'Won'].sort_values("rating_difference", ascending=False).head(top_n)


def get_highest_rated_opponent(df: pd.DataFrame) -> pd.DataFrame:
    return df.iloc[df.opponent_rating.idxmax()].to_frame().transpose()


def get_opponent_rating_distr_fig(df: pd.DataFrame):
    fig = plt.figure()
    plt.title('Opponent rating distribution')
    sns.histplot(data=df, x="opponent_rating", hue='result')
    plt.xlabel('Opponent rating')
    return fig


def get_opponent_rating_dist_over_time_fig(df: pd.DataFrame, is_tournament: bool):
    fig, ax = plt.subplots(figsize=(12, 8))
    plt.title(f'Opponent rating distribution over time')
    x_key_name = "tournament_end_date" if is_tournament else "event_date"
    sns.violinplot(data=df,
                   x=df[x_key_name].dt.year,
                   y="opponent_rating",
                   hue="result",
                   split=True,
                   inner='points',
                   cut=1,
                   ax=ax)
    plt.xticks(rotation=30)
    plt.xlabel('Competition year')
    plt.ylabel('Opponent rating')
    return fig


def load_match_df(file_path: Path) -> Tuple[pd.DataFrame, bool]:
    match_type = _check_match_type(file_path.name.split('_')[0])
    is_tournament = match_type == "tournament"

    df = pd.read_csv(file_path)
    df = _rename_columns(df, is_tournament)
    df = _fix_dtypes(df, is_tournament)

    return df, is_tournament


def usatt_rating_analyzer(file_obj):
    # Load data.
    df, is_tournament = load_match_df(Path(file_obj.name))

    # Create outputs.
    current_rating = get_current_rating(df)
    peak_rating = get_max_rating(df)
    n_competitions_played = get_num_competitions_played(df, is_tournament)
    n_matches_played = len(df)
    matches_per_competition_fig = get_matches_per_competition_fig(df, is_tournament)
    opponent_name_word_cloud_fig = get_opponent_name_word_cloud_fig(df)
    competition_name_word_cloud_fig = get_competition_name_word_cloud_fig(df, is_tournament)
    most_frequent_opponents = make_df_columns_readable(get_most_frequent_opponents(df), is_tournament)
    best_wins = make_df_columns_readable(get_best_wins(df), is_tournament)
    biggest_upsets = make_df_columns_readable(get_biggest_upsets(df), is_tournament)
    highest_rated_opponent = make_df_columns_readable(get_highest_rated_opponent(df), is_tournament)
    rating_over_time_fig = get_rating_over_time_fig(df, is_tournament)
    match_with_longest_game = make_df_columns_readable(get_match_with_longest_game(df, is_tournament), is_tournament)
    opponent_rating_distr_fig = get_opponent_rating_distr_fig(df)
    opponent_rating_dist_over_time_fig = get_opponent_rating_dist_over_time_fig(df, is_tournament)

    return (current_rating,
            peak_rating,
            n_competitions_played,
            n_matches_played,
            rating_over_time_fig,
            opponent_rating_distr_fig,
            opponent_rating_dist_over_time_fig,
            best_wins,
            biggest_upsets,
            most_frequent_opponents,
            highest_rated_opponent,
            match_with_longest_game,
            opponent_name_word_cloud_fig,
            competition_name_word_cloud_fig,
            matches_per_competition_fig,
            )


with gr.Blocks() as demo:
    analyze_btn_title = "Analyze"
    gr.Markdown(f"""# USATT rating analyzer
    Analyze [USA table tennis](https://www.teamusa.org/usa-table-tennis) tournament and league results. The more matches
     and competitions you have played, the better the tool works. Additionally, due to limitations on the available 
    data, ratings are always displayed as the rating received *after* the competition has been played.
    ## Downloading match results
    1. Make sure you are [logged in](https://usatt.simplycompete.com/login/auth) to your USATT account.
    2. Find the *active* player you wish to analyze (e.g.,  [Kanak Jha](https://usatt.simplycompete.com/userAccount/up/3431)).
    3. Under 'Tournaments' or 'Leagues', click *Download Tournament/League Match History*.
    ## Usage
    1. Simply add your tournament/league match history CSV file and click the "{analyze_btn_title}" button.
    
    ---
    
    """)
    with gr.Row():
        with gr.Column():
            input_file = gr.File(label='USATT Results File', file_types=['file'])
            btn = gr.Button(analyze_btn_title)

    gr.Markdown("""<br />
    
    ## Overview
    
    <br />
    """)

    with gr.Group():
        with gr.Row():
            with gr.Column():
                current_rating_box = gr.Textbox(lines=1, label="Current rating")
            with gr.Column():
                peak_rating_box = gr.Textbox(lines=1, label="Highest rating")
            with gr.Column():
                num_comps_box = gr.Textbox(lines=1, label="Number of competitions (tournaments/leagues) played")
            with gr.Column():
                num_matches_box = gr.Textbox(lines=1, label="Number of matches played")

        with gr.Row():
            with gr.Column():
                rating_over_time_plot = gr.Plot(show_label=False)

        with gr.Row():
            with gr.Column():
                opponent_rating_dist_plot = gr.Plot(show_label=False)
            with gr.Column():
                opponent_rating_dist_over_time_plot = gr.Plot(show_label=False)

        gr.Markdown("""<br />

        ## Best Matches

        <br />
        """)

        with gr.Row():
            with gr.Column():
                best_wins_gdf = gr.Dataframe(label="Best wins (matches won sorted by opponent post-competition rating)",
                                             max_rows=5)
                biggest_upsets_gdf = gr.Dataframe(label="Biggest upsets (matches won sorted by rating - opponent post-competition rating)",
                                                  max_rows=5)

        gr.Markdown("""<br />
        
        ## Fun Facts
        
        <br />
        """)

        with gr.Row():
            with gr.Column():
                most_frequent_opponents_gdf = gr.Dataframe(label="Most frequent opponents", max_rows=5)
                highest_rated_opponent_gdf = gr.Dataframe(label="Best opponent", max_rows=1)
                match_longest_game_gdf = gr.Dataframe(label="Match with longest game", max_rows=1)

        with gr.Row():
            with gr.Column():
                opponent_names_plot = gr.Plot(label="Opponent names")
            with gr.Column():
                comp_names_plot = gr.Plot(label="Competition names")
            with gr.Column():
                matches_per_comp_plot = gr.Plot(show_label=False)


    inputs = [input_file]
    outputs = [
        current_rating_box,
        peak_rating_box,
        num_comps_box,
        num_matches_box,
        rating_over_time_plot,
        opponent_rating_dist_plot,
        opponent_rating_dist_over_time_plot,
        best_wins_gdf,
        biggest_upsets_gdf,
        most_frequent_opponents_gdf,
        highest_rated_opponent_gdf,
        match_longest_game_gdf,
        opponent_names_plot,
        comp_names_plot,
        matches_per_comp_plot,
    ]

    btn.click(usatt_rating_analyzer, inputs=inputs, outputs=outputs)

if __name__ == "__main__":
    demo.launch()