Hugging Face's logo

Spaces:
hectorjelly
/
SoccerTwos-Challenge-Analytics-Extra
Runtime error

App Files Community
SoccerTwos-Challenge-Analytics-Extra
File size: 4,670 Bytes 
5f0046c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
141ca68
5f0046c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
import pandas as pd
import streamlit as st

# Set page title and favicon
st.set_page_config(page_icon=":soccer:",layout="wide")


st.markdown(
    """
            <style>
                .block-container {
                    padding-top: 1rem;
                }
                #MainMenu {visibility: hidden;}
            </style>
    """,
    unsafe_allow_html=True
)

# Set title and create a new tab for league history
st.title("⚽ SoccerTwos Challenge Analytics Extra!⚽ ")
tab_team, tab_owners = st.tabs(["Form Table", "Games by Author",])

# Match Results
MATCH_RESULTS_URL = "https://huggingface.co/datasets/huggingface-projects/bot-fight-data/raw/main/soccer_history.csv"


@st.cache(ttl=1800)
def fetch_match_history():
    """
    Fetch the match results from the last 24 hours.
    Cache the result for 30min to avoid unnecessary requests.
    Return a DataFrame.
    """
    df = pd.read_csv(MATCH_RESULTS_URL)
    df["timestamp"] = pd.to_datetime(df.timestamp, unit="s")
    df = df[df["timestamp"] >= pd.Timestamp.now() - pd.Timedelta(hours=24)]
    df.columns = ["home", "away", "timestamp", "result"]
    return df


match_df = fetch_match_history()

# Define a function to calculate the total number of matches played
def num_matches_played():
    return match_df.shape[0]

# Get a list of all teams that have played in the last 24 hours
teams = sorted(
    list(pd.concat([match_df["home"], match_df["away"]]).unique()), key=str.casefold
)

# Create the form table, which shows the win percentage for each team
# st.header("Form Table")
team_results = {}
for i, row in match_df.iterrows():
    home_team = row["home"]
    away_team = row["away"]
    result = row["result"]

    if home_team not in team_results:
        team_results[home_team] = [0, 0, 0]

    if away_team not in team_results:
        team_results[away_team] = [0, 0, 0]

    if result == 0:
        team_results[home_team][2] += 1
        team_results[away_team][0] += 1
    elif result == 1:
        team_results[home_team][0] += 1
        team_results[away_team][2] += 1
    else:
        team_results[home_team][1] += 1
        team_results[away_team][1] += 1

# Create a DataFrame from the results dictionary and calculate the win percentage
df = pd.DataFrame.from_dict(
    team_results, orient="index", columns=["wins", "draws", "losses"]
).sort_index()
df[["owner", "team"]] = df.index.to_series().str.split("/", expand=True)
df = df[["owner", "team", "wins", "draws", "losses"]]
df["win_pct"] = (df["wins"] / (df["wins"] + df["draws"] + df["losses"])) * 100


# Get a list of all teams that have played in the last 24 hours


@st.cache(ttl=1800)
def fetch_owners():
    """
    Fetch a list of all owners who have played in the matches, along with the number of teams they own
    and the number of unique teams they played with.
    """
    # Extract the owner name and team name from each home and away team name in the DataFrame
    team_owners = match_df["home"].apply(lambda x: x.split('/')[0]).tolist() + match_df['away'].apply(lambda x: x.split('/')[0]).tolist()
    teams = match_df["home"].apply(lambda x: x.split('/')[1]).tolist() + match_df['away'].apply(lambda x: x.split('/')[1]).tolist()

    # Count the number of games played by each owner and the number of unique teams they played with
    owner_team_counts = {}
    owner_team_set = {}
    for i, team_owner in enumerate(team_owners):
        owner = team_owner.split(' ')[0]
        if owner not in owner_team_counts:
            owner_team_counts[owner] = 1
            owner_team_set[owner] = {teams[i]}
        else:
            owner_team_counts[owner] += 1
            owner_team_set[owner].add(teams[i])

    # Create a DataFrame from the dictionary
    owners_df = pd.DataFrame.from_dict(owner_team_counts, orient="index", columns=["Games played by owner"])
    owners_df["Unique teams by owner"] = owners_df.index.map(lambda x: len(owner_team_set[x]))

    # Return the DataFrame
    return owners_df






# Display the DataFrame as a table, sorted by win percentage
with tab_team:
    st.write("Form Table for previous 24 hours, ranked by win percentage")
    stats = df.sort_values(by="win_pct", ascending=False)
    styled_stats = stats.style.set_table_attributes("style='font-size: 20px'").set_table_styles([dict(selector='th', props=[('max-width', '200px')])])
    styled_stats = styled_stats.set_table_attributes("style='max-height: 1200px; overflow: auto'")
    st.dataframe(styled_stats)


# Create a DataFrame from the list of owners and their number of teams
owners_df = fetch_owners()

# Display the DataFrame as a table
with tab_owners:
    
    st.dataframe(owners_df)